keyIoMockedStatic = mockStatic(KeyIo.class)) {
+ when(KeyIo.decodePaymentAddress(any())).thenReturn(paymentAddress);
+ when(paymentAddress.getD()).thenReturn(diversifierT);
+ when(paymentAddress.getPkD()).thenReturn("pkd".getBytes());
+ Method privateMethod = Wallet.class.getDeclaredMethod(
+ "buildShieldedTRC20Input",
+ ShieldedTRC20ParametersBuilder.class,
+ GrpcAPI.SpendNoteTRC20.class,
+ ExpandedSpendingKey.class);
+ privateMethod.setAccessible(true);
+ privateMethod.invoke(wallet,
+ builder,
+ spendNote,
+ expandedSpendingKey);
+ }
+ }
+
+ @Test
+ public void testGetContractInfo() throws Exception {
+ Wallet wallet = new Wallet();
+ GrpcAPI.BytesMessage bytesMessage = GrpcAPI.BytesMessage.newBuilder()
+ .setValue(ByteString.copyFrom("test".getBytes()))
+ .build();
+
+ ChainBaseManager chainBaseManagerMock = mock(ChainBaseManager.class);
+ AccountStore accountStore = mock(AccountStore.class);
+ Field field = wallet.getClass().getDeclaredField("chainBaseManager");
+ field.setAccessible(true);
+ field.set(wallet, chainBaseManagerMock);
+ when(chainBaseManagerMock.getAccountStore()).thenReturn(accountStore);
+ when(accountStore.get(any())).thenReturn(null);
+
+ SmartContractOuterClass.SmartContractDataWrapper smartContractDataWrapper =
+ wallet.getContractInfo(bytesMessage);
+ assertNull(smartContractDataWrapper);
+ }
+
+ @Test
+ public void testGetContractInfo1() throws Exception {
+ Wallet wallet = new Wallet();
+ GrpcAPI.BytesMessage bytesMessage = GrpcAPI.BytesMessage.newBuilder()
+ .setValue(ByteString.copyFrom("test".getBytes()))
+ .build();
+
+ ChainBaseManager chainBaseManagerMock = mock(ChainBaseManager.class);
+ AccountStore accountStore = mock(AccountStore.class);
+ ContractStore contractStore = mock(ContractStore.class);
+ AbiStore abiStore = mock(AbiStore.class);
+ CodeStore codeStore = mock(CodeStore.class);
+ ContractStateStore contractStateStore = mock(ContractStateStore.class);
+ DynamicPropertiesStore dynamicPropertiesStore = mock(DynamicPropertiesStore.class);
+
+ AccountCapsule accountCapsule = mock(AccountCapsule.class);
+ ContractCapsule contractCapsule = mock(ContractCapsule.class);
+ ContractStateCapsule contractStateCapsule = new ContractStateCapsule(10L);
+
+ Field field = wallet.getClass().getDeclaredField("chainBaseManager");
+ field.setAccessible(true);
+ field.set(wallet, chainBaseManagerMock);
+ when(chainBaseManagerMock.getAccountStore()).thenReturn(accountStore);
+ when(chainBaseManagerMock.getContractStore()).thenReturn(contractStore);
+ when(chainBaseManagerMock.getAbiStore()).thenReturn(abiStore);
+ when(chainBaseManagerMock.getCodeStore()).thenReturn(codeStore);
+ when(chainBaseManagerMock.getContractStateStore()).thenReturn(contractStateStore);
+ when(chainBaseManagerMock.getDynamicPropertiesStore()).thenReturn(dynamicPropertiesStore);
+
+ when(accountStore.get(any())).thenReturn(accountCapsule);
+ when(contractStore.get(any())).thenReturn(contractCapsule);
+ when(contractCapsule.generateWrapper())
+ .thenReturn(SmartContractOuterClass.SmartContractDataWrapper.newBuilder().build());
+ when(abiStore.get(any())).thenReturn(null);
+ when(codeStore.get(any())).thenReturn(null);
+ when(contractStateStore.get(any())).thenReturn(contractStateCapsule);
+ when(dynamicPropertiesStore.getCurrentCycleNumber()).thenReturn(100L);
+
+ SmartContractOuterClass.SmartContractDataWrapper smartContractDataWrapper =
+ wallet.getContractInfo(bytesMessage);
+ assertNotNull(smartContractDataWrapper);
+ }
+}
\ No newline at end of file
diff --git a/framework/src/test/java/org/tron/core/WalletTest.java b/framework/src/test/java/org/tron/core/WalletTest.java
index 357a2d2ca08..831490fdca1 100644
--- a/framework/src/test/java/org/tron/core/WalletTest.java
+++ b/framework/src/test/java/org/tron/core/WalletTest.java
@@ -48,6 +48,7 @@
import org.tron.api.GrpcAPI.ProposalList;
import org.tron.common.BaseTest;
import org.tron.common.crypto.ECKey;
+import org.tron.common.parameter.CommonParameter;
import org.tron.common.utils.ByteArray;
import org.tron.common.utils.Utils;
import org.tron.core.actuator.DelegateResourceActuator;
@@ -72,6 +73,8 @@
import org.tron.core.store.DynamicPropertiesStore;
import org.tron.core.utils.ProposalUtil.ProposalType;
import org.tron.core.utils.TransactionUtil;
+import org.tron.core.vm.config.ConfigLoader;
+import org.tron.core.vm.config.VMConfig;
import org.tron.core.vm.program.Program;
import org.tron.protos.Protocol;
import org.tron.protos.Protocol.Block;
@@ -139,7 +142,7 @@ public class WalletTest extends BaseTest {
private static boolean init;
static {
- Args.setParam(new String[]{"-d", dbPath()}, Constant.TEST_CONF);
+ Args.setParam(new String[] {"-d", dbPath()}, Constant.TEST_CONF);
OWNER_ADDRESS = Wallet.getAddressPreFixString() + "548794500882809695a8a687866e76d4271a1abc";
RECEIVER_ADDRESS = Wallet.getAddressPreFixString() + "abd4b9367799eaa3197fecb144eb71de1e049150";
}
@@ -152,7 +155,8 @@ public void before() {
}
initTransaction();
initBlock();
- chainBaseManager.getDynamicPropertiesStore().saveLatestBlockHeaderNumber(5);
+ chainBaseManager.getDynamicPropertiesStore().saveLatestBlockHeaderNumber(BLOCK_NUM_FIVE);
+ chainBaseManager.getDynamicPropertiesStore().saveLatestSolidifiedBlockNum(BLOCK_NUM_TWO);
chainBaseManager.getDelegatedResourceStore().reset();
init = true;
}
@@ -166,6 +170,7 @@ private void initTransaction() {
TRANSACTION_TIMESTAMP_ONE, BLOCK_NUM_ONE);
addTransactionToStore(transaction1);
+ // solidified
transaction2 = getBuildTransaction(
getBuildTransferContract(ACCOUNT_ADDRESS_TWO, ACCOUNT_ADDRESS_THREE),
TRANSACTION_TIMESTAMP_TWO, BLOCK_NUM_TWO);
@@ -284,6 +289,7 @@ private void initBlock() {
private void addBlockToStore(Block block) {
BlockCapsule blockCapsule = new BlockCapsule(block);
+ chainBaseManager.getBlockIndexStore().put(blockCapsule.getBlockId());
chainBaseManager.getBlockStore().put(blockCapsule.getBlockId().getBytes(), blockCapsule);
}
@@ -1043,6 +1049,79 @@ public void testGetAssetIssueByName() {
chainBaseManager.getDynamicPropertiesStore().saveAllowSameTokenName(0);
}
+ @Test
+ @SneakyThrows
+ public void testTriggerConstant() {
+ boolean preDebug = CommonParameter.getInstance().debug;
+ CommonParameter.getInstance().debug = true;
+ ConfigLoader.disable = true;
+ VMConfig.initAllowTvmTransferTrc10(1);
+ VMConfig.initAllowTvmConstantinople(1);
+ VMConfig.initAllowTvmShangHai(1);
+
+ String contractAddress =
+ Wallet.getAddressPreFixString() + "1A622D84ed49f01045f5f1a5AfcEb9c57e9cC3cc";
+
+ AccountCapsule accountCap = new AccountCapsule(
+ ByteString.copyFrom(ByteArray.fromHexString(contractAddress)),
+ Protocol.AccountType.Normal);
+ dbManager.getAccountStore().put(accountCap.createDbKey(), accountCap);
+
+ SmartContractOuterClass.SmartContract smartContract =
+ SmartContractOuterClass.SmartContract.newBuilder().build();
+ ContractCapsule contractCap = new ContractCapsule(smartContract);
+ dbManager.getContractStore().put(ByteArray.fromHexString(contractAddress), contractCap);
+
+ String codeString = "608060405234801561000f575f80fd5b50d3801561001b575f80fd5b50d280156100"
+ + "27575f80fd5b506004361061004c575f3560e01c80638da5cb5b14610050578063f8a8fd6d1461006e57"
+ + "5b5f80fd5b61005861008c565b6040516100659190610269565b60405180910390f35b6100766100af565b"
+ + "6040516100839190610269565b60405180910390f35b5f8054906101000a900473ffffffffffffffffffff"
+ + "ffffffffffffffffffff1681565b5f60017fbe0166938e2ea2f3f3e0746fdaf46e25c4d8de37ce56d70400"
+ + "cf284c80d47bbe601b7f10afab946e2be82aa3e4280cf24e2cab294911c3beb06ca9dd7ead06081265d07f"
+ + "1e1855bcdc3ed57c6f3c3874cde035782427d1236e2d819bd16c75676ecc003a6040515f81526020016040"
+ + "52604051610133949392919061038f565b6020604051602081039080840390855afa158015610153573d5f"
+ + "803e3d5ffd5b505050602060405103515f806101000a81548173ffffffffffffffffffffffffffffffffff"
+ + "ffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550734c95a52686a9b3"
+ + "ff9cf787b94b8549a988334c5773ffffffffffffffffffffffffffffffffffffffff165f8054906101000a"
+ + "900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffff"
+ + "ffff1614610205575f80fd5b5f8054906101000a900473ffffffffffffffffffffffffffffffffffffffff"
+ + "16905090565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6102538261"
+ + "022a565b9050919050565b61026381610249565b82525050565b5f60208201905061027c5f83018461025a"
+ + "565b92915050565b5f819050919050565b5f819050919050565b5f815f1b9050919050565b5f6102b96102"
+ + "b46102af84610282565b610294565b61028b565b9050919050565b6102c98161029f565b82525050565b5f"
+ + "819050919050565b5f60ff82169050919050565b5f819050919050565b5f6103076103026102fd846102cf"
+ + "565b6102e4565b6102d8565b9050919050565b610317816102ed565b82525050565b5f819050919050565b"
+ + "5f61034061033b6103368461031d565b610294565b61028b565b9050919050565b61035081610326565b82"
+ + "525050565b5f819050919050565b5f61037961037461036f84610356565b610294565b61028b565b905091"
+ + "9050565b6103898161035f565b82525050565b5f6080820190506103a25f8301876102c0565b6103af6020"
+ + "83018661030e565b6103bc6040830185610347565b6103c96060830184610380565b9594505050505056fe"
+ + "a26474726f6e58221220e967690f9c06386434cbe4d8dd6dce394130f190d17621cbd4ae4cabdef4ad7964"
+ + "736f6c63430008140033";
+ CodeCapsule codeCap = new CodeCapsule(ByteArray.fromHexString(codeString));
+ dbManager.getCodeStore().put(ByteArray.fromHexString(contractAddress), codeCap);
+
+ SmartContractOuterClass.TriggerSmartContract contract =
+ SmartContractOuterClass.TriggerSmartContract.newBuilder()
+ .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(contractAddress)))
+ .setContractAddress(ByteString.copyFrom(ByteArray.fromHexString(contractAddress)))
+ .setData(ByteString.copyFrom(ByteArray.fromHexString("f8a8fd6d")))
+ .build();
+ TransactionCapsule trxCap = wallet.createTransactionCapsule(contract,
+ ContractType.TriggerSmartContract);
+
+ GrpcAPI.TransactionExtention.Builder trxExtBuilder = GrpcAPI.TransactionExtention.newBuilder();
+ GrpcAPI.Return.Builder retBuilder = GrpcAPI.Return.newBuilder();
+
+ Transaction tx = wallet.triggerConstantContract(contract, trxCap, trxExtBuilder, retBuilder);
+ Assert.assertEquals(Transaction.Result.code.SUCESS, tx.getRet(0).getRet());
+
+ VMConfig.initAllowTvmTransferTrc10(0);
+ VMConfig.initAllowTvmConstantinople(0);
+ VMConfig.initAllowTvmShangHai(0);
+ ConfigLoader.disable = false;
+ CommonParameter.getInstance().debug = preDebug;
+ }
+
@Test
@SneakyThrows
public void testEstimateEnergy() {
@@ -1169,19 +1248,19 @@ public void testListNodes() {
* delegate_balance = 1000_000L; => 277
* delegate_balance = 1000_000_000L; => 279
* delegate_balance = 1000_000_000_000L => 280
- *
+ *
* We initialize account information as follows
* account balance = 1000_000_000_000L
* account frozen_balance = 1000_000_000L
- *
+ *
* then estimateConsumeBandWidthSize cost 279
- *
+ *
* so we have following result:
* TransactionUtil.estimateConsumeBandWidthSize(
* dynamicStore,ownerCapsule.getBalance()) ===> false
* TransactionUtil.estimateConsumeBandWidthSize(
* dynamicStore,ownerCapsule.getFrozenV2BalanceForBandwidth()) ===> true
- *
+ *
* This test case is used to verify the above conclusions
*/
@Test
@@ -1206,5 +1285,13 @@ public void testGetCanDelegatedMaxSizeBandWidth123() {
chainBaseManager.getDynamicPropertiesStore().saveMaxDelegateLockPeriod(DELEGATE_PERIOD / 3000);
}
+ @Test
+ public void testGetSolidBlock() {
+ long blkNum = wallet.getSolidBlockNum();
+ Assert.assertEquals(BLOCK_NUM_TWO, blkNum);
+
+ Block block = wallet.getSolidBlock();
+ assertEquals(block2, block);
+ }
}
diff --git a/framework/src/test/java/org/tron/core/actuator/ActuatorFactoryTest.java b/framework/src/test/java/org/tron/core/actuator/ActuatorFactoryTest.java
new file mode 100644
index 00000000000..8258fbf9a3e
--- /dev/null
+++ b/framework/src/test/java/org/tron/core/actuator/ActuatorFactoryTest.java
@@ -0,0 +1,71 @@
+package org.tron.core.actuator;
+
+import com.google.protobuf.ByteString;
+import java.util.List;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.tron.common.BaseTest;
+import org.tron.common.utils.ByteArray;
+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.args.Args;
+import org.tron.protos.Protocol.AccountType;
+import org.tron.protos.contract.BalanceContract.TransferContract;
+
+public class ActuatorFactoryTest extends BaseTest {
+
+ private static final String OWNER_ADDRESS = Wallet.getAddressPreFixString()
+ + "548794500882809695a8a687866e76d4271a1abc";
+ private static final String TO_ADDRESS = Wallet.getAddressPreFixString()
+ + "abd4b9367799eaa3197fecb144eb71de1e049abc";
+
+ static {
+ Args.setParam(
+ new String[] {
+ "--output-directory", dbPath()
+ },
+ Constant.TEST_CONF
+ );
+ }
+
+ private TransferContract getContract(long count, String owneraddress, String toaddress) {
+ return TransferContract.newBuilder()
+ .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(owneraddress)))
+ .setToAddress(ByteString.copyFrom(ByteArray.fromHexString(toaddress)))
+ .setAmount(count)
+ .build();
+ }
+
+ @Before
+ public void createCapsule() {
+ AccountCapsule ownerCapsule =
+ new AccountCapsule(
+ ByteString.copyFromUtf8("owner"),
+ ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS)),
+ AccountType.Normal,
+ 10000L);
+ AccountCapsule toAccountCapsule =
+ new AccountCapsule(
+ ByteString.copyFromUtf8("toAccount"),
+ ByteString.copyFrom(ByteArray.fromHexString(TO_ADDRESS)),
+ AccountType.Normal,
+ 10L);
+ dbManager.getAccountStore().put(ownerCapsule.getAddress().toByteArray(), ownerCapsule);
+ dbManager.getAccountStore().put(toAccountCapsule.getAddress().toByteArray(), toAccountCapsule);
+ }
+
+
+ @Test
+ public void testCreateActuator() {
+ TransferContract contract = getContract(10L, OWNER_ADDRESS, TO_ADDRESS);
+ TransactionCapsule trx = new TransactionCapsule(contract,
+ chainBaseManager.getAccountStore());
+ List actList = ActuatorFactory.createActuator(trx, chainBaseManager);
+
+ Assert.assertEquals(1, actList.size());
+ }
+
+}
diff --git a/framework/src/test/java/org/tron/core/actuator/ExchangeCreateActuatorTest.java b/framework/src/test/java/org/tron/core/actuator/ExchangeCreateActuatorTest.java
index 807d0e1be02..179ba56e7ed 100644
--- a/framework/src/test/java/org/tron/core/actuator/ExchangeCreateActuatorTest.java
+++ b/framework/src/test/java/org/tron/core/actuator/ExchangeCreateActuatorTest.java
@@ -125,8 +125,8 @@ public void sameTokenNameCloseSuccessExchangeCreate() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -216,7 +216,7 @@ public void sameTokenNameCloseSuccessExchangeCreate2() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
accountCapsule.setBalance(200_000_000_000000L);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), 200_000_000L);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), 200_000_000L, true);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
ExchangeCreateActuator actuator = new ExchangeCreateActuator();
@@ -710,8 +710,8 @@ public void sameTokenNameCloseNoEnoughBalance() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance, true);
accountCapsule.setBalance(1000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -748,8 +748,8 @@ public void sameTokenNameOpenNoEnoughBalance() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance, true);
accountCapsule.setBalance(1000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -785,8 +785,8 @@ public void sameTokenNameCloseSameTokens() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -822,8 +822,8 @@ public void sameTokenNameOpenSameTokens() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -859,8 +859,8 @@ public void sameTokenNameCloseLessToken() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), 1000);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), 1000);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), 1000, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), 1000, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -897,8 +897,8 @@ public void sameTokenNameOpenLessToken() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), 1000);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), 1000);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), 1000, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), 1000, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -934,8 +934,8 @@ public void sameTokenNameCloseMoreThanBalanceLimit() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -972,8 +972,8 @@ public void sameTokenNameOpenMoreThanBalanceLimit() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenBalance, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1010,7 +1010,7 @@ public void sameTokenNameCloseBalanceNotEnough() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
accountCapsule.setBalance(firstTokenBalance + 1000L);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), 200_000_000L);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), 200_000_000L, false);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
ExchangeCreateActuator actuator = new ExchangeCreateActuator();
@@ -1047,7 +1047,7 @@ public void sameTokenNameOpenBalanceNotEnough() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
accountCapsule.setBalance(firstTokenBalance + 1000L);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), 200_000_000L);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), 200_000_000L, false);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
ExchangeCreateActuator actuator = new ExchangeCreateActuator();
@@ -1082,8 +1082,8 @@ public void sameTokenNameCloseFirstTokenBalanceNotEnough() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance - 1000L);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), 200_000_000L);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance - 1000L, false);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), 200_000_000L, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1120,8 +1120,8 @@ public void sameTokenNameOpenFirstTokenBalanceNotEnough() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance - 1000L);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), 200_000_000L);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance - 1000L, false);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), 200_000_000L, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1158,7 +1158,7 @@ public void sameTokenNameCloseBalanceNotEnough2() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
accountCapsule.setBalance(secondTokenBalance + 1000L);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), 200_000_000L);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), 200_000_000L, false);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
ExchangeCreateActuator actuator = new ExchangeCreateActuator();
@@ -1195,7 +1195,7 @@ public void sameTokenNameOpenBalanceNotEnough2() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
accountCapsule.setBalance(secondTokenBalance + 1000L);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), 200_000_000L);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), 200_000_000L, false);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
ExchangeCreateActuator actuator = new ExchangeCreateActuator();
@@ -1230,8 +1230,8 @@ public void sameTokenNameCloseSecondTokenBalanceNotEnough() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), 90_000_000L);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance, false);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), 90_000_000L, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1268,8 +1268,8 @@ public void sameTokenNameOpenSecondTokenBalanceNotEnough() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), 90_000_000L);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), 90_000_000L, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1305,7 +1305,7 @@ public void sameTokenNameCloseSecondTokenNotExist() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1342,7 +1342,7 @@ public void sameTokenNameOpenSecondTokenNotExist() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenBalance, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1388,7 +1388,7 @@ public void commonErrorCheck() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
accountCapsule.setBalance(200_000_000_000000L);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), 200_000_000L);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), 200_000_000L, true);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
actuatorTest.setContract(getContract(
diff --git a/framework/src/test/java/org/tron/core/actuator/ExchangeInjectActuatorTest.java b/framework/src/test/java/org/tron/core/actuator/ExchangeInjectActuatorTest.java
index 6268c226c7e..7aef11ed793 100644
--- a/framework/src/test/java/org/tron/core/actuator/ExchangeInjectActuatorTest.java
+++ b/framework/src/test/java/org/tron/core/actuator/ExchangeInjectActuatorTest.java
@@ -190,8 +190,8 @@ public void SameTokenNameCloseSuccessExchangeInject() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, false);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -451,7 +451,7 @@ public void SameTokenNameCloseSuccessExchangeInject2() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, false);
accountCapsule.setBalance(firstTokenQuant);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -731,8 +731,8 @@ public void SameTokenNameCloseExchangeNotExist() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -819,8 +819,8 @@ public void SameTokenNameCloseAccountIsNotCreator() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -910,7 +910,7 @@ public void SameTokenNameCloseTokenIsNotInExchange() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, false);
accountCapsule.setBalance(firstTokenQuant);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -995,8 +995,8 @@ public void SameTokenNameCloseTokenBalanceZero() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant, false);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, false);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1099,8 +1099,8 @@ public void SameTokenNameCloseTokenQuantLessThanZero() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), 1000L);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), 1000L, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1187,7 +1187,7 @@ public void SameTokenNameCloseCalculatedTokenQuantLessThanZero() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, true);
accountCapsule.setBalance(firstTokenQuant);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1273,7 +1273,7 @@ public void SameTokenNameCloseTokenBalanceGreaterThanBalanceLimit() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, true);
accountCapsule.setBalance(firstTokenQuant);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1358,7 +1358,7 @@ public void SameTokenNameCloseBalanceNotEnough() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, true);
accountCapsule.setBalance(firstTokenQuant - 1);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1445,8 +1445,8 @@ public void SameTokenNameCloseTokenBalanceNotEnough() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant - 1);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant - 1, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1533,7 +1533,7 @@ public void SameTokenNameCloseBalanceNotEnough2() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, true);
accountCapsule.setBalance(399_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1618,8 +1618,8 @@ public void SameTokenNameCloseAnotherTokenBalanceNotEnough() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant - 1);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant - 1, false);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, false);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1785,8 +1785,8 @@ public void sameTokennullTransationResult() {
TransactionResultCapsule ret = null;
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
diff --git a/framework/src/test/java/org/tron/core/actuator/ExchangeTransactionActuatorTest.java b/framework/src/test/java/org/tron/core/actuator/ExchangeTransactionActuatorTest.java
index 02107427cad..d39706e0699 100644
--- a/framework/src/test/java/org/tron/core/actuator/ExchangeTransactionActuatorTest.java
+++ b/framework/src/test/java/org/tron/core/actuator/ExchangeTransactionActuatorTest.java
@@ -430,7 +430,7 @@ public void SameTokenNameCloseSuccessExchangeTransaction2() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(tokenId.getBytes(), 10000);
+ accountCapsule.addAssetAmount(tokenId.getBytes(), 10000, true);
Map assetMap = accountCapsule.getAssetMapForTest();
Assert.assertEquals(20000_000000L, accountCapsule.getBalance());
Assert.assertEquals(null, assetMap.get(buyTokenId));
@@ -588,7 +588,7 @@ public void SameTokenNameCloseInvalidAddress() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(tokenId.getBytes(), 10000);
+ accountCapsule.addAssetAmount(tokenId.getBytes(), 10000, false);
Map assetMap = accountCapsule.getAssetMapForTest();
Assert.assertEquals(20000_000000L, accountCapsule.getBalance());
Assert.assertEquals(null, assetMap.get(buyTokenId));
@@ -679,7 +679,7 @@ public void SameTokenNameCloseNoEnoughBalance() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(tokenId.getBytes(), 10000);
+ accountCapsule.addAssetAmount(tokenId.getBytes(), 10000, false);
Map assetMap = accountCapsule.getAssetMapForTest();
Assert.assertEquals(20000_000000L, accountCapsule.getBalance());
Assert.assertEquals(null, assetMap.get(buyTokenId));
@@ -729,7 +729,7 @@ public void SameTokenNameOpenNoEnoughBalance() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(tokenId.getBytes(), 10000);
+ accountCapsule.addAssetAmount(tokenId.getBytes(), 10000, true);
Map assetMap = accountCapsule.getAssetMapForTest();
Assert.assertEquals(20000_000000L, accountCapsule.getBalance());
Assert.assertEquals(null, assetMap.get(buyTokenId));
@@ -779,7 +779,7 @@ public void SameTokenNameCloseNoAccount() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(tokenId.getBytes(), 10000);
+ accountCapsule.addAssetAmount(tokenId.getBytes(), 10000, true);
Map assetMap = accountCapsule.getAssetMapForTest();
Assert.assertEquals(20000_000000L, accountCapsule.getBalance());
Assert.assertEquals(null, assetMap.get(buyTokenId));
@@ -870,7 +870,7 @@ public void SameTokenNameCloseExchangeNotExist() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(tokenId.getBytes(), 10000);
+ accountCapsule.addAssetAmount(tokenId.getBytes(), 10000, true);
Map assetMap = accountCapsule.getAssetMapForTest();
Assert.assertEquals(20000_000000L, accountCapsule.getBalance());
Assert.assertEquals(null, assetMap.get(buyTokenId));
@@ -959,7 +959,7 @@ public void SameTokenNameCloseTokenIsNotInExchange() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(tokenId.getBytes(), 10000);
+ accountCapsule.addAssetAmount(tokenId.getBytes(), 10000, true);
Map assetMap = accountCapsule.getAssetMapForTest();
Assert.assertEquals(20000_000000L, accountCapsule.getBalance());
Assert.assertEquals(null, assetMap.get(buyTokenId));
@@ -1049,7 +1049,7 @@ public void SameTokenNameCloseTokenBalanceZero() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(tokenId.getBytes(), 10000);
+ accountCapsule.addAssetAmount(tokenId.getBytes(), 10000, true);
Map assetMap = accountCapsule.getAssetMapForTest();
Assert.assertEquals(20000_000000L, accountCapsule.getBalance());
Assert.assertEquals(null, assetMap.get(buyTokenId));
@@ -1155,7 +1155,7 @@ public void SameTokenNameCloseTokenQuantLessThanZero() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(tokenId.getBytes(), 10000);
+ accountCapsule.addAssetAmount(tokenId.getBytes(), 10000, true);
Map assetMap = accountCapsule.getAssetMapForTest();
Assert.assertEquals(20000_000000L, accountCapsule.getBalance());
Assert.assertEquals(null, assetMap.get(buyTokenId));
@@ -1245,7 +1245,7 @@ public void SameTokenNameCloseTokenBalanceGreaterThanBalanceLimit() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(tokenId.getBytes(), 10000);
+ accountCapsule.addAssetAmount(tokenId.getBytes(), 10000, true);
Map assetMap = accountCapsule.getAssetMapForTest();
Assert.assertEquals(20000_000000L, accountCapsule.getBalance());
Assert.assertEquals(null, assetMap.get(buyTokenId));
@@ -1421,7 +1421,7 @@ public void SameTokenNameCloseTokenBalanceNotEnough() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(tokenId.getBytes(), quant - 1);
+ accountCapsule.addAssetAmount(tokenId.getBytes(), quant - 1, true);
Map assetMap = accountCapsule.getAssetMapForTest();
Assert.assertEquals(20000_000000L, accountCapsule.getBalance());
Assert.assertEquals(null, assetMap.get(buyTokenId));
@@ -1502,6 +1502,7 @@ public void SameTokenNameOpenTokenBalanceNotEnough() {
@Test
public void SameTokenNameCloseTokenRequiredNotEnough() {
dbManager.getDynamicPropertiesStore().saveAllowSameTokenName(0);
+ final boolean useStrictMath = dbManager.getDynamicPropertiesStore().allowStrictMath();
InitExchangeBeforeSameTokenNameActive();
long exchangeId = 2;
String tokenId = "abc";
@@ -1510,7 +1511,7 @@ public void SameTokenNameCloseTokenRequiredNotEnough() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(tokenId.getBytes(), quant);
+ accountCapsule.addAssetAmount(tokenId.getBytes(), quant, true);
Map assetMap = accountCapsule.getAssetMapForTest();
Assert.assertEquals(20000_000000L, accountCapsule.getBalance());
Assert.assertEquals(null, assetMap.get(buyTokenId));
@@ -1520,7 +1521,7 @@ public void SameTokenNameCloseTokenRequiredNotEnough() {
try {
ExchangeCapsule exchangeCapsule = dbManager.getExchangeStore()
.get(ByteArray.fromLong(exchangeId));
- expected = exchangeCapsule.transaction(tokenId.getBytes(), quant);
+ expected = exchangeCapsule.transaction(tokenId.getBytes(), quant, useStrictMath);
} catch (ItemNotFoundException e) {
fail();
}
@@ -1555,6 +1556,7 @@ public void SameTokenNameCloseTokenRequiredNotEnough() {
@Test
public void SameTokenNameOpenTokenRequiredNotEnough() {
dbManager.getDynamicPropertiesStore().saveAllowSameTokenName(1);
+ final boolean useStrictMath = dbManager.getDynamicPropertiesStore().allowStrictMath();
InitExchangeSameTokenNameActive();
long exchangeId = 2;
String tokenId = "123";
@@ -1575,7 +1577,7 @@ public void SameTokenNameOpenTokenRequiredNotEnough() {
try {
ExchangeCapsule exchangeCapsuleV2 = dbManager.getExchangeV2Store()
.get(ByteArray.fromLong(exchangeId));
- expected = exchangeCapsuleV2.transaction(tokenId.getBytes(), quant);
+ expected = exchangeCapsuleV2.transaction(tokenId.getBytes(), quant, useStrictMath);
} catch (ItemNotFoundException e) {
fail();
}
diff --git a/framework/src/test/java/org/tron/core/actuator/ExchangeWithdrawActuatorTest.java b/framework/src/test/java/org/tron/core/actuator/ExchangeWithdrawActuatorTest.java
index 6844925288e..5c5536f873c 100644
--- a/framework/src/test/java/org/tron/core/actuator/ExchangeWithdrawActuatorTest.java
+++ b/framework/src/test/java/org/tron/core/actuator/ExchangeWithdrawActuatorTest.java
@@ -851,8 +851,8 @@ public void SameTokenNameCloseAccountIsNotCreator() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_SECOND);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -943,7 +943,7 @@ public void SameTokenNameCloseTokenIsNotInExchange() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, true);
accountCapsule.setBalance(firstTokenQuant);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1030,8 +1030,8 @@ public void SameTokenNameCloseTokenBalanceZero() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), firstTokenQuant, false);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, false);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1136,8 +1136,8 @@ public void SameTokenNameCloseTokenQuantLessThanZero() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), 1000L);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), 1000L, true);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, true);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
@@ -1227,8 +1227,8 @@ public void SameTokenNameCloseTnotherTokenQuantLessThanZero() {
byte[] ownerAddress = ByteArray.fromHexString(OWNER_ADDRESS_FIRST);
AccountCapsule accountCapsule = dbManager.getAccountStore().get(ownerAddress);
- accountCapsule.addAssetAmount(firstTokenId.getBytes(), 1000L);
- accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant);
+ accountCapsule.addAssetAmount(firstTokenId.getBytes(), 1000L, false);
+ accountCapsule.addAssetAmount(secondTokenId.getBytes(), secondTokenQuant, false);
accountCapsule.setBalance(10000_000000L);
dbManager.getAccountStore().put(ownerAddress, accountCapsule);
diff --git a/framework/src/test/java/org/tron/core/actuator/ParticipateAssetIssueActuatorTest.java b/framework/src/test/java/org/tron/core/actuator/ParticipateAssetIssueActuatorTest.java
index 52e5f554374..88db0791b0a 100755
--- a/framework/src/test/java/org/tron/core/actuator/ParticipateAssetIssueActuatorTest.java
+++ b/framework/src/test/java/org/tron/core/actuator/ParticipateAssetIssueActuatorTest.java
@@ -1230,7 +1230,7 @@ public void sameTokenNameCloseNotEnoughAssetTest() {
AccountCapsule toAccount =
chainBaseManager.getAccountStore().get(ByteArray.fromHexString(TO_ADDRESS));
toAccount.reduceAssetAmount(ByteString.copyFromUtf8(ASSET_NAME).toByteArray(),
- TOTAL_SUPPLY - 10000);
+ TOTAL_SUPPLY - 10000, true);
chainBaseManager.getAccountStore().put(toAccount.getAddress().toByteArray(), toAccount);
ParticipateAssetIssueActuator actuator = new ParticipateAssetIssueActuator();
actuator.setChainBaseManager(chainBaseManager).setAny(getContract(1));
diff --git a/framework/src/test/java/org/tron/core/actuator/ProposalCreateActuatorTest.java b/framework/src/test/java/org/tron/core/actuator/ProposalCreateActuatorTest.java
index a42a4ffbe5a..7210fe8d074 100644
--- a/framework/src/test/java/org/tron/core/actuator/ProposalCreateActuatorTest.java
+++ b/framework/src/test/java/org/tron/core/actuator/ProposalCreateActuatorTest.java
@@ -1,6 +1,10 @@
package org.tron.core.actuator;
import static junit.framework.TestCase.fail;
+import static org.junit.Assert.assertThrows;
+import static org.tron.core.Constant.CREATE_ACCOUNT_TRANSACTION_MAX_BYTE_SIZE;
+import static org.tron.core.Constant.CREATE_ACCOUNT_TRANSACTION_MIN_BYTE_SIZE;
+import static org.tron.core.config.Parameter.ChainConstant.ONE_YEAR_BLOCK_NUMBERS;
import com.google.protobuf.Any;
import com.google.protobuf.ByteString;
@@ -9,8 +13,10 @@
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mockito;
import org.tron.common.BaseTest;
import org.tron.common.utils.ByteArray;
+import org.tron.common.utils.ForkController;
import org.tron.core.Constant;
import org.tron.core.Wallet;
import org.tron.core.capsule.AccountCapsule;
@@ -279,6 +285,50 @@ public void invalidPara() {
Assert.assertEquals("This value[REMOVE_THE_POWER_OF_THE_GR] is only allowed to be 1",
e.getMessage());
}
+ // verify Proposal No. 78
+ paras = new HashMap<>();
+ paras.put(78L, 10L);
+ actuator = new ProposalCreateActuator();
+ actuator.setChainBaseManager(dbManager.getChainBaseManager())
+ .setForkUtils(dbManager.getChainBaseManager().getForkController())
+ .setAny(getContract(OWNER_ADDRESS_FIRST, paras));
+ assertThrows(
+ "Bad chain parameter id [MAX_DELEGATE_LOCK_PERIOD]",
+ ContractValidateException.class, actuator::validate);
+
+ actuator = new ProposalCreateActuator();
+ ForkController forkController = Mockito.mock(ForkController.class);
+ Mockito.when(forkController.pass(Mockito.any())).thenReturn(true);
+ actuator.setChainBaseManager(dbManager.getChainBaseManager())
+ .setForkUtils(forkController)
+ .setAny(getContract(OWNER_ADDRESS_FIRST, paras));
+ dbManager.getDynamicPropertiesStore().saveMaxDelegateLockPeriod(86400L);
+ long maxDelegateLockPeriod = dbManager.getDynamicPropertiesStore().getMaxDelegateLockPeriod();
+ assertThrows(
+ "This value[MAX_DELEGATE_LOCK_PERIOD] is only allowed to be greater than "
+ + maxDelegateLockPeriod + " and less than or equal to " + ONE_YEAR_BLOCK_NUMBERS + "!",
+ ContractValidateException.class, actuator::validate);
+
+ // verify Proposal No. 82
+ paras = new HashMap<>();
+ paras.put(82L, 0L);
+ actuator = new ProposalCreateActuator();
+ actuator.setChainBaseManager(dbManager.getChainBaseManager())
+ .setForkUtils(dbManager.getChainBaseManager().getForkController())
+ .setAny(getContract(OWNER_ADDRESS_FIRST, paras));
+ assertThrows(
+ "Bad chain parameter id [ALLOW_ENERGY_ADJUSTMENT]",
+ ContractValidateException.class, actuator::validate);
+
+ actuator = new ProposalCreateActuator();
+ actuator.setChainBaseManager(dbManager.getChainBaseManager())
+ .setForkUtils(forkController)
+ .setAny(getContract(OWNER_ADDRESS_FIRST, paras));
+ assertThrows(
+ "This value[MAX_CREATE_ACCOUNT_TX_SIZE] is only allowed to be greater than or equal "
+ + "to " + CREATE_ACCOUNT_TRANSACTION_MIN_BYTE_SIZE + " and less than or equal to "
+ + CREATE_ACCOUNT_TRANSACTION_MAX_BYTE_SIZE + "!",
+ ContractValidateException.class, actuator::validate);
}
/**
diff --git a/framework/src/test/java/org/tron/core/actuator/UpdateSettingContractActuatorTest.java b/framework/src/test/java/org/tron/core/actuator/UpdateSettingContractActuatorTest.java
index 508cee731f0..213bbd6cb85 100644
--- a/framework/src/test/java/org/tron/core/actuator/UpdateSettingContractActuatorTest.java
+++ b/framework/src/test/java/org/tron/core/actuator/UpdateSettingContractActuatorTest.java
@@ -108,8 +108,8 @@ public void successUpdateSettingContract() {
Assert.assertEquals(ret.getInstance().getRet(), Protocol.Transaction.Result.code.SUCESS);
Assert.assertEquals(
dbManager.getContractStore().get(ByteArray.fromHexString(CONTRACT_ADDRESS))
- .getConsumeUserResourcePercent(),
- TARGET_PERCENT);
+ .getConsumeUserResourcePercent(
+ dbManager.getDynamicPropertiesStore().disableJavaLangMath()), TARGET_PERCENT);
} catch (ContractValidateException e) {
Assert.assertFalse(e instanceof ContractValidateException);
} catch (ContractExeException e) {
@@ -245,8 +245,8 @@ public void twiceUpdateSettingContract() {
Assert.assertEquals(ret.getInstance().getRet(), Protocol.Transaction.Result.code.SUCESS);
Assert.assertEquals(
dbManager.getContractStore().get(ByteArray.fromHexString(CONTRACT_ADDRESS))
- .getConsumeUserResourcePercent(),
- TARGET_PERCENT);
+ .getConsumeUserResourcePercent(
+ dbManager.getDynamicPropertiesStore().disableJavaLangMath()), TARGET_PERCENT);
// second
secondActuator.validate();
@@ -255,8 +255,8 @@ public void twiceUpdateSettingContract() {
Assert.assertEquals(ret.getInstance().getRet(), Protocol.Transaction.Result.code.SUCESS);
Assert.assertEquals(
dbManager.getContractStore().get(ByteArray.fromHexString(CONTRACT_ADDRESS))
- .getConsumeUserResourcePercent(),
- 90L);
+ .getConsumeUserResourcePercent(
+ dbManager.getDynamicPropertiesStore().disableJavaLangMath()), 90L);
} catch (ContractValidateException e) {
Assert.assertFalse(e instanceof ContractValidateException);
diff --git a/framework/src/test/java/org/tron/core/actuator/VoteWitnessActuatorTest.java b/framework/src/test/java/org/tron/core/actuator/VoteWitnessActuatorTest.java
index 1a152555931..d7fef2ab2f5 100644
--- a/framework/src/test/java/org/tron/core/actuator/VoteWitnessActuatorTest.java
+++ b/framework/src/test/java/org/tron/core/actuator/VoteWitnessActuatorTest.java
@@ -52,6 +52,7 @@ public class VoteWitnessActuatorTest extends BaseTest {
static {
Args.setParam(new String[]{"--output-directory", dbPath()}, Constant.TEST_CONF);
+ Args.getInstance().setConsensusLogicOptimization(1);
OWNER_ADDRESS = Wallet.getAddressPreFixString() + "abd4b9367799eaa3197fecb144eb71de1e049abc";
WITNESS_ADDRESS = Wallet.getAddressPreFixString() + "548794500882809695a8a687866e76d4271a1abc";
WITNESS_ADDRESS_NOACCOUNT =
diff --git a/framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java b/framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java
index 6f4df3cba8f..e8a1e862f54 100644
--- a/framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java
+++ b/framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java
@@ -3,7 +3,10 @@
import com.google.protobuf.ByteString;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
+import javax.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
import org.junit.BeforeClass;
@@ -12,13 +15,17 @@
import org.tron.common.utils.ByteArray;
import org.tron.common.utils.ForkController;
import org.tron.core.Constant;
+import org.tron.core.capsule.BytesCapsule;
+import org.tron.core.capsule.ProposalCapsule;
import org.tron.core.config.Parameter;
import org.tron.core.config.Parameter.ForkBlockVersionEnum;
import org.tron.core.config.args.Args;
+import org.tron.core.consensus.ProposalService;
import org.tron.core.exception.ContractValidateException;
import org.tron.core.store.DynamicPropertiesStore;
import org.tron.core.utils.ProposalUtil;
import org.tron.core.utils.ProposalUtil.ProposalType;
+import org.tron.protos.Protocol;
@Slf4j(topic = "actuator")
public class ProposalUtilTest extends BaseTest {
@@ -27,6 +34,11 @@ public class ProposalUtilTest extends BaseTest {
private static final String LONG_VALUE_ERROR =
"Bad chain parameter value, valid range is [0," + LONG_VALUE + "]";
+ @Resource
+ private DynamicPropertiesStore dynamicPropertiesStore;
+
+ ForkController forkUtils = ForkController.instance();
+
/**
* Init .
*/
@@ -60,8 +72,6 @@ public void validProposalTypeCheck() throws ContractValidateException {
@Test
public void validateCheck() {
- DynamicPropertiesStore dynamicPropertiesStore = null;
- ForkController forkUtils = ForkController.instance();
long invalidValue = -1;
try {
@@ -328,11 +338,327 @@ public void validateCheck() {
e.getMessage());
}
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_OLD_REWARD_OPT.getCode(), 2);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "Bad chain parameter id [ALLOW_OLD_REWARD_OPT]",
+ e.getMessage());
+ }
+ hardForkTime =
+ ((ForkBlockVersionEnum.VERSION_4_7_4.getHardForkTime() - 1) / maintenanceTimeInterval + 1)
+ * maintenanceTimeInterval;
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .saveLatestBlockHeaderTimestamp(hardForkTime + 1);
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .statsByVersion(ForkBlockVersionEnum.VERSION_4_7_4.getValue(), stats);
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_OLD_REWARD_OPT.getCode(), 2);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "This value[ALLOW_OLD_REWARD_OPT] is only allowed to be 1",
+ e.getMessage());
+ }
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_OLD_REWARD_OPT.getCode(), 1);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "[ALLOW_NEW_REWARD] or [ALLOW_TVM_VOTE] proposal must be approved "
+ + "before [ALLOW_OLD_REWARD_OPT] can be proposed",
+ e.getMessage());
+ }
+ dynamicPropertiesStore.put("NEW_REWARD_ALGORITHM_EFFECTIVE_CYCLE".getBytes(),
+ new BytesCapsule(ByteArray.fromLong(4000)));
+ dynamicPropertiesStore.saveAllowOldRewardOpt(1);
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_OLD_REWARD_OPT.getCode(), 1);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "[ALLOW_OLD_REWARD_OPT] has been valid, no need to propose again",
+ e.getMessage());
+ }
+
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_STRICT_MATH.getCode(), 2);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "Bad chain parameter id [ALLOW_STRICT_MATH]",
+ e.getMessage());
+ }
+ hardForkTime =
+ ((ForkBlockVersionEnum.VERSION_4_7_7.getHardForkTime() - 1) / maintenanceTimeInterval + 1)
+ * maintenanceTimeInterval;
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .saveLatestBlockHeaderTimestamp(hardForkTime + 1);
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .statsByVersion(ForkBlockVersionEnum.VERSION_4_7_7.getValue(), stats);
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_STRICT_MATH.getCode(), 2);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "This value[ALLOW_STRICT_MATH] is only allowed to be 1",
+ e.getMessage());
+ }
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_STRICT_MATH.getCode(), 1);
+ } catch (ContractValidateException e) {
+ Assert.fail(e.getMessage());
+ }
+ Protocol.Proposal proposal = Protocol.Proposal.newBuilder().putParameters(
+ ProposalType.ALLOW_STRICT_MATH.getCode(), 1).build();
+ ProposalCapsule proposalCapsule = new ProposalCapsule(proposal);
+ ProposalService.process(dbManager, proposalCapsule);
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_STRICT_MATH.getCode(), 1);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "[ALLOW_STRICT_MATH] has been valid, no need to propose again",
+ e.getMessage());
+ }
+
+ testEnergyAdjustmentProposal();
+
+ testConsensusLogicOptimizationProposal();
+
+ testAllowTvmCancunProposal();
+
+ testAllowTvmBlobProposal();
+
forkUtils.getManager().getDynamicPropertiesStore()
.statsByVersion(ForkBlockVersionEnum.ENERGY_LIMIT.getValue(), stats);
forkUtils.reset();
}
+ private void testEnergyAdjustmentProposal() {
+ // Should fail because cannot pass the fork controller check
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_ENERGY_ADJUSTMENT.getCode(), 1);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "Bad chain parameter id [ALLOW_ENERGY_ADJUSTMENT]",
+ e.getMessage());
+ }
+
+ long maintenanceTimeInterval = forkUtils.getManager().getDynamicPropertiesStore()
+ .getMaintenanceTimeInterval();
+
+ long hardForkTime =
+ ((ForkBlockVersionEnum.VERSION_4_7_5.getHardForkTime() - 1) / maintenanceTimeInterval + 1)
+ * maintenanceTimeInterval;
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .saveLatestBlockHeaderTimestamp(hardForkTime + 1);
+
+ byte[] stats = new byte[27];
+ Arrays.fill(stats, (byte) 1);
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .statsByVersion(ForkBlockVersionEnum.VERSION_4_7_5.getValue(), stats);
+
+ // Should fail because the proposal value is invalid
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_ENERGY_ADJUSTMENT.getCode(), 2);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "This value[ALLOW_ENERGY_ADJUSTMENT] is only allowed to be 1",
+ e.getMessage());
+ }
+
+ // Should succeed
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_ENERGY_ADJUSTMENT.getCode(), 1);
+ } catch (Throwable t) {
+ Assert.fail();
+ }
+
+ ProposalCapsule proposalCapsule = new ProposalCapsule(ByteString.empty(), 0);
+ Map parameter = new HashMap<>();
+ parameter.put(81L, 1L);
+ proposalCapsule.setParameters(parameter);
+ ProposalService.process(dbManager, proposalCapsule);
+
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_ENERGY_ADJUSTMENT.getCode(), 1);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "[ALLOW_ENERGY_ADJUSTMENT] has been valid, no need to propose again",
+ e.getMessage());
+ }
+ }
+
+ private void testConsensusLogicOptimizationProposal() {
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.CONSENSUS_LOGIC_OPTIMIZATION.getCode(), 1);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "Bad chain parameter id [CONSENSUS_LOGIC_OPTIMIZATION]",
+ e.getMessage());
+ }
+
+ long maintenanceTimeInterval = forkUtils.getManager().getDynamicPropertiesStore()
+ .getMaintenanceTimeInterval();
+
+ long hardForkTime =
+ ((ForkBlockVersionEnum.VERSION_4_8_0.getHardForkTime() - 1) / maintenanceTimeInterval + 1)
+ * maintenanceTimeInterval;
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .saveLatestBlockHeaderTimestamp(hardForkTime + 1);
+
+ byte[] stats = new byte[27];
+ Arrays.fill(stats, (byte) 1);
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .statsByVersion(ForkBlockVersionEnum.VERSION_4_8_0.getValue(), stats);
+
+ // Should fail because the proposal value is invalid
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.CONSENSUS_LOGIC_OPTIMIZATION.getCode(), 2);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "This value[CONSENSUS_LOGIC_OPTIMIZATION] is only allowed to be 1",
+ e.getMessage());
+ }
+
+ dynamicPropertiesStore.saveConsensusLogicOptimization(1);
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.CONSENSUS_LOGIC_OPTIMIZATION.getCode(), 1);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "[CONSENSUS_LOGIC_OPTIMIZATION] has been valid, no need to propose again",
+ e.getMessage());
+ }
+
+ }
+
+ private void testAllowTvmCancunProposal() {
+ byte[] stats = new byte[27];
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .statsByVersion(ForkBlockVersionEnum.VERSION_4_8_0.getValue(), stats);
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_TVM_CANCUN.getCode(), 1);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "Bad chain parameter id [ALLOW_TVM_CANCUN]",
+ e.getMessage());
+ }
+
+ long maintenanceTimeInterval = forkUtils.getManager().getDynamicPropertiesStore()
+ .getMaintenanceTimeInterval();
+
+ long hardForkTime =
+ ((ForkBlockVersionEnum.VERSION_4_8_0.getHardForkTime() - 1) / maintenanceTimeInterval + 1)
+ * maintenanceTimeInterval;
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .saveLatestBlockHeaderTimestamp(hardForkTime + 1);
+
+ stats = new byte[27];
+ Arrays.fill(stats, (byte) 1);
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .statsByVersion(ForkBlockVersionEnum.VERSION_4_8_0.getValue(), stats);
+
+ // Should fail because the proposal value is invalid
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_TVM_CANCUN.getCode(), 2);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "This value[ALLOW_TVM_CANCUN] is only allowed to be 1",
+ e.getMessage());
+ }
+
+ dynamicPropertiesStore.saveAllowTvmCancun(1);
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_TVM_CANCUN.getCode(), 1);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "[ALLOW_TVM_CANCUN] has been valid, no need to propose again",
+ e.getMessage());
+ }
+
+ }
+
+ private void testAllowTvmBlobProposal() {
+ byte[] stats = new byte[27];
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .statsByVersion(ForkBlockVersionEnum.VERSION_4_8_0.getValue(), stats);
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_TVM_BLOB.getCode(), 1);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "Bad chain parameter id [ALLOW_TVM_BLOB]",
+ e.getMessage());
+ }
+
+ long maintenanceTimeInterval = forkUtils.getManager().getDynamicPropertiesStore()
+ .getMaintenanceTimeInterval();
+
+ long hardForkTime =
+ ((ForkBlockVersionEnum.VERSION_4_8_0.getHardForkTime() - 1) / maintenanceTimeInterval + 1)
+ * maintenanceTimeInterval;
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .saveLatestBlockHeaderTimestamp(hardForkTime + 1);
+
+ stats = new byte[27];
+ Arrays.fill(stats, (byte) 1);
+ forkUtils.getManager().getDynamicPropertiesStore()
+ .statsByVersion(ForkBlockVersionEnum.VERSION_4_8_0.getValue(), stats);
+
+ // Should fail because the proposal value is invalid
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_TVM_BLOB.getCode(), 2);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "This value[ALLOW_TVM_BLOB] is only allowed to be 1",
+ e.getMessage());
+ }
+
+ dynamicPropertiesStore.saveAllowTvmBlob(1);
+ try {
+ ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+ ProposalType.ALLOW_TVM_BLOB.getCode(), 1);
+ Assert.fail();
+ } catch (ContractValidateException e) {
+ Assert.assertEquals(
+ "[ALLOW_TVM_BLOB] has been valid, no need to propose again",
+ e.getMessage());
+ }
+
+ }
+
@Test
public void blockVersionCheck() {
for (ForkBlockVersionEnum forkVersion : ForkBlockVersionEnum.values()) {
diff --git a/framework/src/test/java/org/tron/core/actuator/utils/TransactionUtilTest.java b/framework/src/test/java/org/tron/core/actuator/utils/TransactionUtilTest.java
index 9d56876a4da..0eb69f8fd66 100644
--- a/framework/src/test/java/org/tron/core/actuator/utils/TransactionUtilTest.java
+++ b/framework/src/test/java/org/tron/core/actuator/utils/TransactionUtilTest.java
@@ -3,6 +3,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import static org.tron.common.math.Maths.max;
import static org.tron.core.capsule.utils.TransactionUtil.isNumber;
import static org.tron.core.config.Parameter.ChainConstant.DELEGATE_COST_BASE_SIZE;
import static org.tron.core.config.Parameter.ChainConstant.DELEGATE_PERIOD;
@@ -14,6 +15,7 @@
import com.google.protobuf.ByteString;
import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
import java.util.List;
import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
@@ -113,7 +115,7 @@ public static long estimateConsumeBandWidthSize(final AccountCapsule ownerCapsul
TransactionCapsule fakeTransactionCapsule2 = new TransactionCapsule(builder2.build(),
ContractType.DelegateResourceContract);
long size2 = consumeBandWidthSize(fakeTransactionCapsule2, chainBaseManager);
- long addSize = Math.max(size1 - size2, 0L);
+ long addSize = max(size1 - size2, 0L, true);
return DELEGATE_COST_BASE_SIZE + addSize;
}
@@ -134,7 +136,7 @@ public static long estimateConsumeBandWidthSizeOld(
TransactionCapsule fakeTransactionCapsule2 = new TransactionCapsule(builder2.build(),
ContractType.DelegateResourceContract);
long size2 = consumeBandWidthSize(fakeTransactionCapsule2, chainBaseManager);
- long addSize = Math.max(size1 - size2, 0L);
+ long addSize = max(size1 - size2, 0L, true);
return DELEGATE_COST_BASE_SIZE + addSize;
}
@@ -372,8 +374,8 @@ public void estimateConsumeBandWidthSizePositive() {
DelegateResourceContract.newBuilder()
.setBalance(TRX_PRECISION);
- long expected = DELEGATE_COST_BASE_SIZE + Math.max(
- builder.build().getSerializedSize() - builder2.build().getSerializedSize(), 0L);
+ long expected = DELEGATE_COST_BASE_SIZE + max(
+ builder.build().getSerializedSize() - builder2.build().getSerializedSize(), 0L, true);
long actual = TransactionUtil.estimateConsumeBandWidthSize(dps, balance);
Assert.assertEquals(expected, actual);
}
@@ -390,8 +392,8 @@ public void estimateConsumeBandWidthSizeBoundary() {
DelegateResourceContract.newBuilder()
.setBalance(TRX_PRECISION);
- long expected = DELEGATE_COST_BASE_SIZE + Math.max(
- builder.build().getSerializedSize() - builder2.build().getSerializedSize(), 0L);
+ long expected = DELEGATE_COST_BASE_SIZE + max(
+ builder.build().getSerializedSize() - builder2.build().getSerializedSize(), 0L, true);
long actual = TransactionUtil.estimateConsumeBandWidthSize(dps, balance);
Assert.assertEquals(expected, actual);
}
@@ -408,8 +410,8 @@ public void estimateConsumeBandWidthSizeEdge() {
DelegateResourceContract.newBuilder()
.setBalance(TRX_PRECISION);
- long expected = DELEGATE_COST_BASE_SIZE + Math.max(
- builder.build().getSerializedSize() - builder2.build().getSerializedSize(), 0L);
+ long expected = DELEGATE_COST_BASE_SIZE + max(
+ builder.build().getSerializedSize() - builder2.build().getSerializedSize(), 0L, true);
long actual = TransactionUtil.estimateConsumeBandWidthSize(dps, balance);
Assert.assertEquals(expected, actual);
}
@@ -426,9 +428,27 @@ public void estimateConsumeBandWidthSizeCorner() {
DelegateResourceContract.newBuilder()
.setBalance(TRX_PRECISION);
- long expected = DELEGATE_COST_BASE_SIZE + Math.max(
- builder.build().getSerializedSize() - builder2.build().getSerializedSize(), 0L);
+ long expected = DELEGATE_COST_BASE_SIZE + max(
+ builder.build().getSerializedSize() - builder2.build().getSerializedSize(), 0L, true);
long actual = TransactionUtil.estimateConsumeBandWidthSize(dps, balance);
Assert.assertEquals(expected, actual);
}
+
+ @Test
+ public void testConcurrentToString() throws InterruptedException {
+ Transaction.Builder builder = Transaction.newBuilder();
+ TransactionCapsule trx = new TransactionCapsule(builder.build());
+ List threadList = new ArrayList<>();
+ int n = 10;
+ for (int i = 0; i < n; i++) {
+ threadList.add(new Thread(() -> trx.toString()));
+ }
+ for (int i = 0; i < n; i++) {
+ threadList.get(i).start();
+ }
+ for (int i = 0; i < n; i++) {
+ threadList.get(i).join();
+ }
+ Assert.assertTrue(true);
+ }
}
diff --git a/framework/src/test/java/org/tron/core/capsule/AccountCapsuleTest.java b/framework/src/test/java/org/tron/core/capsule/AccountCapsuleTest.java
index de72b4be276..7a217dfd787 100644
--- a/framework/src/test/java/org/tron/core/capsule/AccountCapsuleTest.java
+++ b/framework/src/test/java/org/tron/core/capsule/AccountCapsuleTest.java
@@ -36,7 +36,7 @@ public class AccountCapsuleTest extends BaseTest {
static AccountCapsule accountCapsule;
static {
- Args.setParam(new String[]{"-d", dbPath(), "-w"}, Constant.TEST_CONF);
+ Args.setParam(new String[]{"-d", dbPath()}, Constant.TEST_CONF);
OWNER_ADDRESS = Wallet.getAddressPreFixString() + "a06a17a49648a8ad32055c06f60fa14ae46df91234";
}
@@ -90,7 +90,7 @@ public void AssetAmountTest() {
String nameAdd = "TokenX";
long amountAdd = 222L;
boolean addBoolean = accountCapsuleTest
- .addAssetAmount(nameAdd.getBytes(), amountAdd);
+ .addAssetAmount(nameAdd.getBytes(), amountAdd, true);
Assert.assertTrue(addBoolean);
@@ -102,7 +102,7 @@ public void AssetAmountTest() {
long amountReduce = 22L;
boolean reduceBoolean = accountCapsuleTest
- .reduceAssetAmount(ByteArray.fromString("TokenX"), amountReduce);
+ .reduceAssetAmount(ByteArray.fromString("TokenX"), amountReduce, false);
Assert.assertTrue(reduceBoolean);
Map assetMapAfter = accountCapsuleTest.getAssetMapForTest();
diff --git a/framework/src/test/java/org/tron/core/capsule/BlockCapsuleTest.java b/framework/src/test/java/org/tron/core/capsule/BlockCapsuleTest.java
index 0dd078dedb0..3c86d893895 100644
--- a/framework/src/test/java/org/tron/core/capsule/BlockCapsuleTest.java
+++ b/framework/src/test/java/org/tron/core/capsule/BlockCapsuleTest.java
@@ -2,7 +2,9 @@
import com.google.protobuf.ByteString;
import java.io.IOException;
+import java.util.ArrayList;
import java.util.Arrays;
+import java.util.List;
import lombok.extern.slf4j.Slf4j;
import org.junit.AfterClass;
import org.junit.Assert;
@@ -146,4 +148,20 @@ public void testGetTimeStamp() {
Assert.assertEquals(1234L, blockCapsule0.getTimeStamp());
}
+ @Test
+ public void testConcurrentToString() throws InterruptedException {
+ List threadList = new ArrayList<>();
+ int n = 10;
+ for (int i = 0; i < n; i++) {
+ threadList.add(new Thread(() -> blockCapsule0.toString()));
+ }
+ for (int i = 0; i < n; i++) {
+ threadList.get(i).start();
+ }
+ for (int i = 0; i < n; i++) {
+ threadList.get(i).join();
+ }
+ Assert.assertTrue(true);
+ }
+
}
diff --git a/framework/src/test/java/org/tron/core/capsule/ContractStateCapsuleTest.java b/framework/src/test/java/org/tron/core/capsule/ContractStateCapsuleTest.java
index 90f74074a9b..c90ad89abb3 100644
--- a/framework/src/test/java/org/tron/core/capsule/ContractStateCapsuleTest.java
+++ b/framework/src/test/java/org/tron/core/capsule/ContractStateCapsuleTest.java
@@ -1,7 +1,12 @@
package org.tron.core.capsule;
+import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
+import org.mockito.Mockito;
+import org.tron.core.config.args.Args;
+import org.tron.core.store.DynamicPropertiesStore;
+import org.tron.core.vm.config.VMConfig;
import org.tron.protos.contract.SmartContractOuterClass;
public class ContractStateCapsuleTest {
@@ -15,12 +20,12 @@ public void testCatchUpCycle() {
.setUpdateCycle(1000L)
.build());
- Assert.assertFalse(capsule.catchUpToCycle(1000L, 2_000_000L, 2000L, 10_00L));
+ Assert.assertFalse(capsule.catchUpToCycle(1000L, 2_000_000L, 2000L, 10_00L, false, false));
Assert.assertEquals(1000L, capsule.getUpdateCycle());
Assert.assertEquals(1_000_000L, capsule.getEnergyUsage());
Assert.assertEquals(5000L, capsule.getEnergyFactor());
- Assert.assertTrue(capsule.catchUpToCycle(1010L, 900_000L, 1000L, 10_000L));
+ Assert.assertTrue(capsule.catchUpToCycle(1010L, 900_000L, 1000L, 10_000L, false, false));
Assert.assertEquals(1010L, capsule.getUpdateCycle());
Assert.assertEquals(0L, capsule.getEnergyUsage());
Assert.assertEquals(3137L, capsule.getEnergyFactor());
@@ -32,7 +37,7 @@ public void testCatchUpCycle() {
.setUpdateCycle(1000L)
.build());
- Assert.assertTrue(capsule.catchUpToCycle(1001L, 2_000_000L, 2000L, 10_000L));
+ Assert.assertTrue(capsule.catchUpToCycle(1001L, 2_000_000L, 2000L, 10_000L, false, false));
Assert.assertEquals(1001L, capsule.getUpdateCycle());
Assert.assertEquals(0L, capsule.getEnergyUsage());
Assert.assertEquals(4250L, capsule.getEnergyFactor());
@@ -44,7 +49,7 @@ public void testCatchUpCycle() {
.setUpdateCycle(1000L)
.build());
- Assert.assertTrue(capsule.catchUpToCycle(1001L, 1_000_000L, 2000L, 10_000L));
+ Assert.assertTrue(capsule.catchUpToCycle(1001L, 1_000_000L, 2000L, 10_000L, false, false));
Assert.assertEquals(1001L, capsule.getUpdateCycle());
Assert.assertEquals(0L, capsule.getEnergyUsage());
Assert.assertEquals(4250L, capsule.getEnergyFactor());
@@ -56,7 +61,7 @@ public void testCatchUpCycle() {
.setUpdateCycle(1000L)
.build());
- Assert.assertTrue(capsule.catchUpToCycle(1001L, 900_000L, 2000L, 10_000L));
+ Assert.assertTrue(capsule.catchUpToCycle(1001L, 900_000L, 2000L, 10_000L, false, false));
Assert.assertEquals(1001L, capsule.getUpdateCycle());
Assert.assertEquals(0L, capsule.getEnergyUsage());
Assert.assertEquals(8000L, capsule.getEnergyFactor());
@@ -68,7 +73,7 @@ public void testCatchUpCycle() {
.setUpdateCycle(1000L)
.build());
- Assert.assertTrue(capsule.catchUpToCycle(1001L, 900_000L, 5000L, 10_000L));
+ Assert.assertTrue(capsule.catchUpToCycle(1001L, 900_000L, 5000L, 10_000L, false, false));
Assert.assertEquals(1001L, capsule.getUpdateCycle());
Assert.assertEquals(0L, capsule.getEnergyUsage());
Assert.assertEquals(10_000L, capsule.getEnergyFactor());
@@ -80,7 +85,7 @@ public void testCatchUpCycle() {
.setUpdateCycle(1000L)
.build());
- Assert.assertTrue(capsule.catchUpToCycle(1002L, 900_000L, 5000L, 10_000L));
+ Assert.assertTrue(capsule.catchUpToCycle(1002L, 900_000L, 5000L, 10_000L, false, false));
Assert.assertEquals(1002L, capsule.getUpdateCycle());
Assert.assertEquals(0L, capsule.getEnergyUsage());
Assert.assertEquals(7500L, capsule.getEnergyFactor());
@@ -92,7 +97,7 @@ public void testCatchUpCycle() {
.setUpdateCycle(1000L)
.build());
- Assert.assertTrue(capsule.catchUpToCycle(1003L, 900_000L, 5000L, 10_000L));
+ Assert.assertTrue(capsule.catchUpToCycle(1003L, 900_000L, 5000L, 10_000L, false, false));
Assert.assertEquals(1003L, capsule.getUpdateCycle());
Assert.assertEquals(0L, capsule.getEnergyUsage());
Assert.assertEquals(5312L, capsule.getEnergyFactor());
@@ -104,7 +109,7 @@ public void testCatchUpCycle() {
.setUpdateCycle(1000L)
.build());
- Assert.assertTrue(capsule.catchUpToCycle(1004L, 900_000L, 5000L, 10_000L));
+ Assert.assertTrue(capsule.catchUpToCycle(1004L, 900_000L, 5000L, 10_000L, false, false));
Assert.assertEquals(1004L, capsule.getUpdateCycle());
Assert.assertEquals(0L, capsule.getEnergyUsage());
Assert.assertEquals(3398L, capsule.getEnergyFactor());
@@ -116,7 +121,7 @@ public void testCatchUpCycle() {
.setUpdateCycle(1000L)
.build());
- Assert.assertTrue(capsule.catchUpToCycle(1005L, 900_000L, 5000L, 10_000L));
+ Assert.assertTrue(capsule.catchUpToCycle(1005L, 900_000L, 5000L, 10_000L, true, true));
Assert.assertEquals(1005L, capsule.getUpdateCycle());
Assert.assertEquals(0L, capsule.getEnergyUsage());
Assert.assertEquals(1723L, capsule.getEnergyFactor());
@@ -128,7 +133,7 @@ public void testCatchUpCycle() {
.setUpdateCycle(1000L)
.build());
- Assert.assertTrue(capsule.catchUpToCycle(1005L, 900_000L, 5000L, 10_000L));
+ Assert.assertTrue(capsule.catchUpToCycle(1005L, 900_000L, 5000L, 10_000L, true, true));
Assert.assertEquals(1005L, capsule.getUpdateCycle());
Assert.assertEquals(0L, capsule.getEnergyUsage());
Assert.assertEquals(1723L, capsule.getEnergyFactor());
@@ -140,7 +145,7 @@ public void testCatchUpCycle() {
.setUpdateCycle(1000L)
.build());
- Assert.assertTrue(capsule.catchUpToCycle(1006L, 900_000L, 5000L, 10_000L));
+ Assert.assertTrue(capsule.catchUpToCycle(1006L, 900_000L, 5000L, 10_000L, true, true));
Assert.assertEquals(1006L, capsule.getUpdateCycle());
Assert.assertEquals(0L, capsule.getEnergyUsage());
Assert.assertEquals(258L, capsule.getEnergyFactor());
@@ -151,12 +156,25 @@ public void testCatchUpCycle() {
.setEnergyFactor(5000L)
.setUpdateCycle(1000L)
.build());
-
- Assert.assertTrue(capsule.catchUpToCycle(1007L, 900_000L, 5000L, 10_000L));
+ Args.getInstance().setAllowStrictMath(1);
+ VMConfig.initAllowStrictMath(Args.getInstance().getAllowStrictMath());
+ DynamicPropertiesStore dps = Mockito.mock(DynamicPropertiesStore.class);
+ Mockito.when(dps.getCurrentCycleNumber()).thenReturn(1007L);
+ Mockito.when(dps.getDynamicEnergyThreshold()).thenReturn(900_000L);
+ Mockito.when(dps.getDynamicEnergyIncreaseFactor()).thenReturn(5000L);
+ Mockito.when(dps.getDynamicEnergyMaxFactor()).thenReturn(10_000L);
+ Mockito.when(dps.allowStrictMath()).thenReturn(VMConfig.allowStrictMath());
+ Assert.assertTrue(capsule.catchUpToCycle(dps));
Assert.assertEquals(1007L, capsule.getUpdateCycle());
Assert.assertEquals(0L, capsule.getEnergyUsage());
Assert.assertEquals(0L, capsule.getEnergyFactor());
}
+ @After
+ public void reset() {
+ Args.clearParam();
+
+ }
+
}
diff --git a/framework/src/test/java/org/tron/core/capsule/ExchangeCapsuleTest.java b/framework/src/test/java/org/tron/core/capsule/ExchangeCapsuleTest.java
index 791767a952f..5fcd259d738 100644
--- a/framework/src/test/java/org/tron/core/capsule/ExchangeCapsuleTest.java
+++ b/framework/src/test/java/org/tron/core/capsule/ExchangeCapsuleTest.java
@@ -52,8 +52,8 @@ public void testExchange() {
long sellQuant = 1_000_000L;
byte[] sellID = "abc".getBytes();
-
- long result = exchangeCapsule.transaction(sellID, sellQuant);
+ boolean useStrictMath = chainBaseManager.getDynamicPropertiesStore().allowStrictMath();
+ long result = exchangeCapsule.transaction(sellID, sellQuant, useStrictMath);
Assert.assertEquals(990_099L, result);
sellBalance += sellQuant;
Assert.assertEquals(sellBalance, exchangeCapsule.getFirstTokenBalance());
@@ -61,7 +61,7 @@ public void testExchange() {
Assert.assertEquals(buyBalance, exchangeCapsule.getSecondTokenBalance());
sellQuant = 9_000_000L;
- long result2 = exchangeCapsule.transaction(sellID, sellQuant);
+ long result2 = exchangeCapsule.transaction(sellID, sellQuant, useStrictMath);
Assert.assertEquals(9090909L, result + result2);
sellBalance += sellQuant;
Assert.assertEquals(sellBalance, exchangeCapsule.getFirstTokenBalance());
diff --git a/framework/src/test/java/org/tron/core/capsule/TransactionCapsuleTest.java b/framework/src/test/java/org/tron/core/capsule/TransactionCapsuleTest.java
index fcb2a4fbfd5..7065608f188 100644
--- a/framework/src/test/java/org/tron/core/capsule/TransactionCapsuleTest.java
+++ b/framework/src/test/java/org/tron/core/capsule/TransactionCapsuleTest.java
@@ -1,5 +1,9 @@
package org.tron.core.capsule;
+import static org.tron.protos.Protocol.Transaction.Result.contractResult.BAD_JUMP_DESTINATION;
+import static org.tron.protos.Protocol.Transaction.Result.contractResult.PRECOMPILED_CONTRACT;
+import static org.tron.protos.Protocol.Transaction.Result.contractResult.SUCCESS;
+
import com.google.protobuf.ByteString;
import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
@@ -13,55 +17,20 @@
import org.tron.core.config.args.Args;
import org.tron.protos.Protocol.AccountType;
import org.tron.protos.Protocol.Transaction;
+import org.tron.protos.Protocol.Transaction.Contract.ContractType;
import org.tron.protos.Protocol.Transaction.Result;
import org.tron.protos.Protocol.Transaction.Result.contractResult;
+import org.tron.protos.Protocol.Transaction.raw;
@Slf4j
public class TransactionCapsuleTest extends BaseTest {
private static String OWNER_ADDRESS;
- /*private static String OWNER_KEY =
- "bfa67cb3dc6609b3a0c98e717d66f38ed1a159b5b3421678dfab85961c40de2f";
- private static String TO_ADDRESS;
- private static String OWNER_ACCOUNT_NOT_Exist;
- private static String KEY_11 = "1111111111111111111111111111111111111111111111111111111111111111";
- private static String KEY_12 = "1212121212121212121212121212121212121212121212121212121212121212";
- private static String KEY_13 = "1313131313131313131313131313131313131313131313131313131313131313";
- private static String KEY_21 = "2121212121212121212121212121212121212121212121212121212121212121";
- private static String KEY_22 = "2222222222222222222222222222222222222222222222222222222222222222";
- private static String KEY_23 = "2323232323232323232323232323232323232323232323232323232323232323";
- private static String KEY_31 = "3131313131313131313131313131313131313131313131313131313131313131";
- private static String KEY_32 = "3232323232323232323232323232323232323232323232323232323232323232";
- private static String KEY_33 = "3333333333333333333333333333333333333333333333333333333333333333";
-
- private static String KEY_ADDRESS_11;
- private static String KEY_ADDRESS_12;
- private static String KEY_ADDRESS_13;
- private static String KEY_ADDRESS_21;
- private static String KEY_ADDRESS_22;
- private static String KEY_ADDRESS_23;
- private static String KEY_ADDRESS_31;
- private static String KEY_ADDRESS_32;
- private static String KEY_ADDRESS_33;*/
@BeforeClass
public static void init() {
Args.setParam(new String[]{"-d", dbPath()}, Constant.TEST_CONF);
OWNER_ADDRESS = Wallet.getAddressPreFixString() + "03702350064AD5C1A8AA6B4D74B051199CFF8EA7";
- /*TO_ADDRESS = Wallet.getAddressPreFixString() + "abd4b9367799eaa3197fecb144eb71de1e049abc";
- OWNER_ACCOUNT_NOT_Exist =
- Wallet.getAddressPreFixString() + "548794500882809695a8a687866e76d4271a3456";
- KEY_ADDRESS_11 = Wallet.getAddressPreFixString() + "19E7E376E7C213B7E7E7E46CC70A5DD086DAFF2A";
- KEY_ADDRESS_12 = Wallet.getAddressPreFixString() + "1C5A77D9FA7EF466951B2F01F724BCA3A5820B63";
- KEY_ADDRESS_13 = Wallet.getAddressPreFixString() + "03A1BBA60B5AA37094CF16123ADD674C01589488";
-
- KEY_ADDRESS_21 = Wallet.getAddressPreFixString() + "2BD0C9FE079C8FCA0E3352EB3D02839C371E5C41";
- KEY_ADDRESS_22 = Wallet.getAddressPreFixString() + "1563915E194D8CFBA1943570603F7606A3115508";
- KEY_ADDRESS_23 = Wallet.getAddressPreFixString() + "D3E442496EB66A4748912EC4A3B7A111D0B855D6";
-
- KEY_ADDRESS_31 = Wallet.getAddressPreFixString() + "77952CE83CA3CAD9F7ADCFABEDA85BD2F1F52008";
- KEY_ADDRESS_32 = Wallet.getAddressPreFixString() + "94622CC2A5B64A58C25A129D48A2BEEC4B65B779";
- KEY_ADDRESS_33 = Wallet.getAddressPreFixString() + "5CBDD86A2FA8DC4BDDD8A8F69DBA48572EEC07FB";*/
}
/**
@@ -74,984 +43,6 @@ public void createAccountCapsule() {
dbManager.getAccountStore().put(ownerCapsule.createDbKey(), ownerCapsule);
}
- /*@Test
- public void getDefaultPermission() {
- String[] names = {"active", "owner", "other"};
- ByteString address = ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS));
- for (String name : names) {
- Permission permission = TransactionCapsule
- .getDefaultPermission(address, name);
- Assert.assertEquals(permission.getName(), name);
- Assert.assertEquals(permission.getThreshold(), 1);
- if ("owner".equalsIgnoreCase(name)) {
- Assert.assertEquals(permission.getParent(), "");
- } else {
- Assert.assertEquals(permission.getParent(), "owner");
- }
- Assert.assertEquals(permission.getKeysCount(), 1);
- Key key = permission.getKeys(0);
- Assert.assertEquals(key.getAddress(), address);
- Assert.assertEquals(key.getWeight(), 1);
- }
- }
-
- public TransferContract createTransferContract(byte[] to, byte[] owner, long amount) {
- TransferContract.Builder builder = TransferContract.newBuilder();
- ByteString bsTo = ByteString.copyFrom(to);
- ByteString bsOwner = ByteString.copyFrom(owner);
- builder.setToAddress(bsTo);
- builder.setOwnerAddress(bsOwner);
- builder.setAmount(amount);
-
- return builder.build();
- }
-
- public PermissionAddKeyContract createPermissionAddKeyContract(byte[] owner, String name,
- byte[] address, int weight) {
- PermissionAddKeyContract.Builder contractBuilder = PermissionAddKeyContract.newBuilder();
- contractBuilder.setOwnerAddress(ByteString.copyFrom(owner));
- contractBuilder.setPermissionName(name);
- Key.Builder keyBuilder = Key.newBuilder();
- keyBuilder.setAddress(ByteString.copyFrom(address));
- keyBuilder.setWeight(weight);
- contractBuilder.setKey(keyBuilder.build());
- return contractBuilder.build();
- }
-
- public void updatePermission(List permissions, byte[] address) {
- Account account = dbManager.getAccountStore().get(address).getInstance();
- Account.Builder builder = account.toBuilder();
- for (Permission permission : permissions) {
- builder.addPermissions(permission);
- }
- dbManager.getAccountStore().put(address, new AccountCapsule(builder.build()));
- }
-
- public List buildPermissions() {
- Permission.Builder builder1 = Permission.newBuilder();
- Key.Builder key11 = Key.newBuilder();
- Key.Builder key12 = Key.newBuilder();
- Key.Builder key13 = Key.newBuilder();
- key11.setAddress(ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_11))).setWeight(1);
- key12.setAddress(ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_12))).setWeight(1);
- key13.setAddress(ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_13))).setWeight(1);
- builder1.setName("owner").setThreshold(2).setParent("").addKeys(key11).addKeys(key12)
- .addKeys(key13);
- Permission.Builder builder2 = Permission.newBuilder();
- Key.Builder key21 = Key.newBuilder();
- Key.Builder key22 = Key.newBuilder();
- Key.Builder key23 = Key.newBuilder();
- key21.setAddress(ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_21))).setWeight(1);
- key22.setAddress(ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_22))).setWeight(1);
- key23.setAddress(ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_23))).setWeight(1);
- builder2.setName("active").setThreshold(2).setParent("").addKeys(key21).addKeys(key22)
- .addKeys(key23);
- Permission.Builder builder3 = Permission.newBuilder();
- Key.Builder key31 = Key.newBuilder();
- Key.Builder key32 = Key.newBuilder();
- Key.Builder key33 = Key.newBuilder();
- key31.setAddress(ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_31))).setWeight(1);
- key32.setAddress(ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_32))).setWeight(1);
- key33.setAddress(ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_33))).setWeight(1);
- builder3.setName("other").setThreshold(2).setParent("").addKeys(key31).addKeys(key32)
- .addKeys(key33);
- List list = new ArrayList<>();
- list.add(builder1.build());
- list.add(builder2.build());
- list.add(builder3.build());
- return list;
- }
-
- @Test
- public void getPermission() {
- //Default "active" permission
- byte[] owner = ByteArray.fromHexString(OWNER_ADDRESS);
- Account account = dbManager.getAccountStore().get(owner).getInstance();
- try {
- Permission permission = TransactionCapsule.getPermission(account, "active");
- Permission permission1 = TransactionCapsule
- .getDefaultPermission(ByteString.copyFrom(owner), "active");
- Assert.assertEquals(permission, permission1);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- }
- //Default "owner" permission
- try {
- Permission permission = TransactionCapsule.getPermission(account, "owner");
- Permission permission1 = TransactionCapsule
- .getDefaultPermission(ByteString.copyFrom(owner), "owner");
- Assert.assertEquals(permission, permission1);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- }
- //Add 3 permission : owner active other
- List permissions = buildPermissions();
- updatePermission(permissions, owner);
- Permission permission1 = permissions.get(0);
- Permission permission2 = permissions.get(1);
- account = dbManager.getAccountStore().get(owner).getInstance();
- try {
- Permission permission = TransactionCapsule.getPermission(account, "owner");
- Assert.assertEquals(permission, permission1);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- }
-
- try {
- Permission permission = TransactionCapsule.getPermission(account, "active");
- Assert.assertEquals(permission, permission2);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- }
- }
-
- @Test
- public void getWeight() {
- List permissions = buildPermissions();
- Permission permission1 = permissions.get(0);
- Permission permission2 = permissions.get(1);
- Permission permission3 = permissions.get(2);
- Assert.assertEquals(1,
- TransactionCapsule.getWeight(permission1, ByteArray.fromHexString(KEY_ADDRESS_11)));
- Assert.assertEquals(1,
- TransactionCapsule.getWeight(permission1, ByteArray.fromHexString(KEY_ADDRESS_12)));
- Assert.assertEquals(1,
- TransactionCapsule.getWeight(permission1, ByteArray.fromHexString(KEY_ADDRESS_13)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission1, ByteArray.fromHexString(KEY_ADDRESS_21)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission1, ByteArray.fromHexString(KEY_ADDRESS_22)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission1, ByteArray.fromHexString(KEY_ADDRESS_23)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission1, ByteArray.fromHexString(KEY_ADDRESS_31)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission1, ByteArray.fromHexString(KEY_ADDRESS_32)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission1, ByteArray.fromHexString(KEY_ADDRESS_33)));
-
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission2, ByteArray.fromHexString(KEY_ADDRESS_11)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission2, ByteArray.fromHexString(KEY_ADDRESS_12)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission2, ByteArray.fromHexString(KEY_ADDRESS_13)));
- Assert.assertEquals(1,
- TransactionCapsule.getWeight(permission2, ByteArray.fromHexString(KEY_ADDRESS_21)));
- Assert.assertEquals(1,
- TransactionCapsule.getWeight(permission2, ByteArray.fromHexString(KEY_ADDRESS_22)));
- Assert.assertEquals(1,
- TransactionCapsule.getWeight(permission2, ByteArray.fromHexString(KEY_ADDRESS_23)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission2, ByteArray.fromHexString(KEY_ADDRESS_31)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission2, ByteArray.fromHexString(KEY_ADDRESS_32)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission2, ByteArray.fromHexString(KEY_ADDRESS_33)));
-
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission3, ByteArray.fromHexString(KEY_ADDRESS_11)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission3, ByteArray.fromHexString(KEY_ADDRESS_12)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission3, ByteArray.fromHexString(KEY_ADDRESS_13)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission3, ByteArray.fromHexString(KEY_ADDRESS_21)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission3, ByteArray.fromHexString(KEY_ADDRESS_22)));
- Assert.assertEquals(0,
- TransactionCapsule.getWeight(permission3, ByteArray.fromHexString(KEY_ADDRESS_23)));
- Assert.assertEquals(1,
- TransactionCapsule.getWeight(permission3, ByteArray.fromHexString(KEY_ADDRESS_31)));
- Assert.assertEquals(1,
- TransactionCapsule.getWeight(permission3, ByteArray.fromHexString(KEY_ADDRESS_32)));
- Assert.assertEquals(1,
- TransactionCapsule.getWeight(permission3, ByteArray.fromHexString(KEY_ADDRESS_33)));
- }
-
- public ArrayList sign(List priKeys, byte[] hash) {
- ArrayList list = new ArrayList<>();
- for (byte[] priKey : priKeys) {
- ECKey ecKey = ECKey.fromPrivate(priKey);
- ECDSASignature signature = ecKey.sign(hash);
- ByteString result = ByteString.copyFrom(signature.toByteArray());
- list.add(result);
- }
- return list;
- }
-
- @Test
- public void checkWeight() {
- List permissions = buildPermissions();
- Permission permission = permissions.get(0);
- byte[] hash = Sha256Hash.hash("test".getBytes());
-
- //SignatureFormatException
- ArrayList list = new ArrayList<>();
- ByteString test = ByteString.copyFromUtf8("test");
- list.add(test);
- try {
- TransactionCapsule.checkWeight(permission, list, hash, null);
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertEquals(e.getMessage(), "Signature size is " + test.size());
- }
- //SignatureException: Header byte out of range:
- //Ignore more exception case.
- byte[] rand = new byte[65];
- new Random().nextBytes(rand);
- rand[64] = 8; // v = 8 < 27 v += 35 > 35
- try {
- ArrayList list1 = new ArrayList<>();
- list1.add(ByteString.copyFrom(rand));
- TransactionCapsule.checkWeight(permission, list1, hash, null);
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertEquals(e.getMessage(), "Header byte out of range: 35");
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- //Permission does not contain KEY
- List prikeys = new ArrayList<>();
- prikeys.add(ByteArray.fromHexString(KEY_11));
- prikeys.add(ByteArray.fromHexString(KEY_21));
- ArrayList sign11_21 = sign(prikeys, hash);
- try {
- TransactionCapsule.checkWeight(permission, sign11_21, hash, null);
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- ByteString sign21 = sign11_21.get(1);
- Assert.assertEquals(e.getMessage(),
- ByteArray.toHexString(sign21.toByteArray()) + " is signed by " + Wallet
- .encode58Check(ByteArray.fromHexString(KEY_ADDRESS_21))
- + " but it is not contained of permission.");
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- //Too many signature
- prikeys.add(ByteArray.fromHexString(KEY_12));
- prikeys.add(ByteArray.fromHexString(KEY_13));
- ArrayList sign11_21_12_13 = sign(prikeys, hash);
- try {
- TransactionCapsule.checkWeight(permission, sign11_21_12_13, hash, null);
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertEquals(e.getMessage(),
- "Signature count is " + prikeys.size() + " more than key counts of permission : "
- + permission.getKeysCount());
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
-
- //Sign twice by same key
- prikeys = new ArrayList<>();
- prikeys.add(ByteArray.fromHexString(KEY_11));
- prikeys.add(ByteArray.fromHexString(KEY_12));
- prikeys.add(ByteArray.fromHexString(KEY_11));
- ArrayList sign11_12_11 = sign(prikeys, hash);
- try {
- TransactionCapsule.checkWeight(permission, sign11_12_11, hash, null);
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertEquals(e.getMessage(),
- WalletUtil.encode58Check(ByteArray.fromHexString(KEY_ADDRESS_11)) + " has signed twice!");
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
-
- //
- prikeys = new ArrayList<>();
- List approveList = new ArrayList<>();
- prikeys.add(ByteArray.fromHexString(KEY_11));
- ArrayList sign11 = sign(prikeys, hash);
- try {
- long weight = TransactionCapsule.checkWeight(permission, sign11, hash, approveList);
- Assert.assertEquals(weight, 1);
- Assert.assertEquals(approveList.size(), 1);
- Assert.assertEquals(approveList.get(0),
- ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_11)));
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
-
- approveList = new ArrayList<>();
- prikeys.add(ByteArray.fromHexString(KEY_12));
- ArrayList sign11_12 = sign(prikeys, hash);
- try {
- long weight = TransactionCapsule.checkWeight(permission, sign11_12, hash, approveList);
- Assert.assertEquals(weight, 2);
- Assert.assertEquals(approveList.size(), 2);
- Assert.assertEquals(approveList.get(0),
- ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_11)));
- Assert.assertEquals(approveList.get(1),
- ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_12)));
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
-
- approveList = new ArrayList<>();
- prikeys.add(ByteArray.fromHexString(KEY_13));
- ArrayList sign11_12_13 = sign(prikeys, hash);
- try {
- long weight = TransactionCapsule.checkWeight(permission, sign11_12_13, hash, approveList);
- Assert.assertEquals(weight, 3);
- Assert.assertEquals(approveList.size(), 3);
- Assert.assertEquals(approveList.get(0),
- ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_11)));
- Assert.assertEquals(approveList.get(1),
- ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_12)));
- Assert.assertEquals(approveList.get(2),
- ByteString.copyFrom(ByteArray.fromHexString(KEY_ADDRESS_13)));
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- }
-
- @Test
- public void addSign() {
-
- byte[] to = ByteArray.fromHexString(TO_ADDRESS);
- byte[] owner_not_exist = ByteArray.fromHexString(OWNER_ACCOUNT_NOT_Exist);
- TransferContract transferContract = createTransferContract(to, owner_not_exist, 1);
- Transaction.Builder trxBuilder = Transaction.newBuilder();
- Transaction.raw.Builder rawBuilder = Transaction.raw.newBuilder();
- Contract.Builder contractBuilder = Contract.newBuilder();
- contractBuilder.setType(ContractType.TransferContract).setParameter(Any.pack(transferContract))
- .build();
- rawBuilder.addContract(contractBuilder);
- trxBuilder.setRawData(rawBuilder);
- AccountStore accountStore = dbManager.getAccountStore();
- TransactionCapsule transactionCapsule = new TransactionCapsule(trxBuilder.build());
- //Accout not exist
- try {
- transactionCapsule.addSign(ByteArray.fromHexString(KEY_11), accountStore);
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertEquals(e.getMessage(), "Account is not exist!");
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
-
- byte[] owner = ByteArray.fromHexString(OWNER_ADDRESS);
- transferContract = createTransferContract(to, owner, 1);
- transactionCapsule = new TransactionCapsule(transferContract, accountStore);
- //Defalut permission
- try {
- transactionCapsule.addSign(ByteArray.fromHexString(KEY_11), accountStore);
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertEquals(e.getMessage(),
- KEY_11 + "'s address is " + WalletUtil
- .encode58Check(ByteArray.fromHexString(KEY_ADDRESS_11))
- + " but it is not contained of permission.");
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
-
- try {
- transactionCapsule.addSign(ByteArray.fromHexString(OWNER_KEY), accountStore);
- Assert.assertEquals(transactionCapsule.getInstance().getSignatureCount(), 1);
- ByteString signature = transactionCapsule.getInstance().getSignature(0);
- Assert.assertEquals(signature.size(), 65);
- byte[] sign = signature.toByteArray();
- byte[] r = ByteArray.subArray(sign, 0, 32);
- byte[] s = ByteArray.subArray(sign, 32, 64);
- byte v = sign[64];
- ECDSASignature ecdsaSignature = ECDSASignature.fromComponents(r, s, (byte) (v + 27));
- byte[] address = ECKey
- .signatureToAddress(transactionCapsule.getTransactionId().getBytes(), ecdsaSignature);
- Assert.assertTrue(Arrays.equals(address, ByteArray.fromHexString(OWNER_ADDRESS)));
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- // Sign twice
- try {
- transactionCapsule.addSign(ByteArray.fromHexString(OWNER_KEY), accountStore);
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertEquals(e.getMessage(),
- WalletUtil.encode58Check(ByteArray.fromHexString(OWNER_ADDRESS)) + " had signed!");
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- //Update permission, can signed by key21 key22 key23
- List permissions = buildPermissions();
- Account account = accountStore.get(ByteArray.fromHexString(OWNER_ADDRESS)).getInstance();
- Account.Builder builder = account.toBuilder();
- builder.addPermissions(permissions.get(0));
- builder.addPermissions(permissions.get(1));
- builder.addPermissions(permissions.get(2));
- accountStore.put(ByteArray.fromHexString(OWNER_ADDRESS), new AccountCapsule(builder.build()));
-
- transactionCapsule = new TransactionCapsule(transferContract, accountStore);
- try {
- transactionCapsule.addSign(ByteArray.fromHexString(OWNER_KEY), accountStore);
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertEquals(e.getMessage(),
- OWNER_KEY + "'s address is " + Wallet
- .encode58Check(ByteArray.fromHexString(OWNER_ADDRESS))
- + " but it is not contained of permission.");
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- //Sign KEY_21
- try {
- transactionCapsule.addSign(ByteArray.fromHexString(KEY_21), accountStore);
- Assert.assertEquals(transactionCapsule.getInstance().getSignatureCount(), 1);
- ByteString signature = transactionCapsule.getInstance().getSignature(0);
- Assert.assertEquals(signature.size(), 65);
- byte[] sign = signature.toByteArray();
- byte[] r = ByteArray.subArray(sign, 0, 32);
- byte[] s = ByteArray.subArray(sign, 32, 64);
- byte v = sign[64];
- ECDSASignature ecdsaSignature = ECDSASignature.fromComponents(r, s, (byte) (v + 27));
- byte[] address = ECKey
- .signatureToAddress(transactionCapsule.getTransactionId().getBytes(), ecdsaSignature);
- Assert.assertTrue(Arrays.equals(address, ByteArray.fromHexString(KEY_ADDRESS_21)));
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- //Sign KEY_12
- try {
- transactionCapsule.addSign(ByteArray.fromHexString(KEY_22), accountStore);
- Assert.assertEquals(transactionCapsule.getInstance().getSignatureCount(), 2);
- ByteString signature = transactionCapsule.getInstance().getSignature(0);
- Assert.assertEquals(signature.size(), 65);
- byte[] sign = signature.toByteArray();
- byte[] r21 = ByteArray.subArray(sign, 0, 32);
- byte[] s21 = ByteArray.subArray(sign, 32, 64);
- byte v21 = sign[64];
- ECDSASignature ecdsaSignature11 = ECDSASignature.fromComponents(r21, s21, (byte) (v21 + 27));
- byte[] address21 = ECKey
- .signatureToAddress(transactionCapsule.getTransactionId().getBytes(), ecdsaSignature11);
- Assert.assertTrue(Arrays.equals(address21, ByteArray.fromHexString(KEY_ADDRESS_21)));
-
- ByteString signature1 = transactionCapsule.getInstance().getSignature(1);
-
- byte[] r22 = ByteArray.subArray(signature1.toByteArray(), 0, 32);
- byte[] s22 = ByteArray.subArray(signature1.toByteArray(), 32, 64);
- byte v22 = signature1.toByteArray()[64];
- ECDSASignature ecdsaSignature12 = ECDSASignature.fromComponents(r22, s22, (byte) (v22 + 27));
- byte[] address22 = ECKey
- .signatureToAddress(transactionCapsule.getTransactionId().getBytes(), ecdsaSignature12);
- Assert.assertTrue(Arrays.equals(address22, ByteArray.fromHexString(KEY_ADDRESS_22)));
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- //Sign KEY_23
- try {
- transactionCapsule.addSign(ByteArray.fromHexString(KEY_23), accountStore);
- Assert.assertEquals(transactionCapsule.getInstance().getSignatureCount(), 3);
- ByteString signature = transactionCapsule.getInstance().getSignature(0);
- Assert.assertEquals(signature.size(), 65);
- byte[] sign = signature.toByteArray();
- byte[] r21 = ByteArray.subArray(sign, 0, 32);
- byte[] s21 = ByteArray.subArray(sign, 32, 64);
- byte v21 = sign[64];
- ECDSASignature ecdsaSignature21 = ECDSASignature.fromComponents(r21, s21, (byte) (v21 + 27));
- byte[] address21 = ECKey
- .signatureToAddress(transactionCapsule.getTransactionId().getBytes(), ecdsaSignature21);
- Assert.assertTrue(Arrays.equals(address21, ByteArray.fromHexString(KEY_ADDRESS_21)));
-
- ByteString signature1 = transactionCapsule.getInstance().getSignature(1);
- Assert.assertEquals(signature1.size(), 65);
- byte[] sign1 = signature1.toByteArray();
- byte[] r22 = ByteArray.subArray(sign1, 0, 32);
- byte[] s22 = ByteArray.subArray(sign1, 32, 64);
- byte v22 = sign1[64];
- ECDSASignature ecdsaSignature22 = ECDSASignature.fromComponents(r22, s22, (byte) (v22 + 27));
- byte[] address22 = ECKey
- .signatureToAddress(transactionCapsule.getTransactionId().getBytes(), ecdsaSignature22);
- Assert.assertTrue(Arrays.equals(address22, ByteArray.fromHexString(KEY_ADDRESS_22)));
-
- ByteString signature2 = transactionCapsule.getInstance().getSignature(2);
- Assert.assertEquals(signature2.size(), 65);
- byte[] sign2 = signature2.toByteArray();
- byte[] r23 = ByteArray.subArray(sign2, 0, 32);
- byte[] s23 = ByteArray.subArray(sign2, 32, 64);
- byte v23 = sign2[64];
- ECDSASignature ecdsaSignature23 = ECDSASignature.fromComponents(r23, s23, (byte) (v23 + 27));
- byte[] address23 = ECKey
- .signatureToAddress(transactionCapsule.getTransactionId().getBytes(), ecdsaSignature23);
- Assert.assertTrue(Arrays.equals(address23, ByteArray.fromHexString(KEY_ADDRESS_23)));
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- //Sign KEY_11, throw exception
- try {
- transactionCapsule.addSign(ByteArray.fromHexString(KEY_11), accountStore);
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertEquals(e.getMessage(),
- KEY_11 + "'s address is " + Wallet
- .encode58Check(ByteArray.fromHexString(KEY_ADDRESS_11))
- + " but it is not contained of permission.");
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- //invalidate signature
- transactionCapsule = new TransactionCapsule(transferContract, accountStore);
- Transaction.Builder builder1 = transactionCapsule.getInstance().toBuilder();
- builder1.addSignature(ByteString.copyFromUtf8("test"));
- transactionCapsule = new TransactionCapsule(builder1.build());
- //Sign KEY_21, throw exception
- try {
- transactionCapsule.addSign(ByteArray.fromHexString(KEY_11), accountStore);
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertEquals(e.getMessage(), "Signature size is " + "test".length());
- }
-
- //invalidate signature
- transactionCapsule = new TransactionCapsule(transferContract, accountStore);
- builder1 = transactionCapsule.getInstance().toBuilder();
- builder1.addSignature(ByteString.copyFromUtf8("test"));
- transactionCapsule = new TransactionCapsule(builder1.build());
- //Sign KEY_21, throw exception
- try {
- transactionCapsule.addSign(ByteArray.fromHexString(KEY_11), accountStore);
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertEquals(e.getMessage(), "Signature size is " + "test".length());
- }
- //transaction already have a signature signed by a invalidate key
- //that the key is not in the permission.
- transactionCapsule = new TransactionCapsule(transferContract, accountStore);
- List prikeys = new ArrayList<>();
- prikeys.add(ByteArray.fromHexString(KEY_11));
- ArrayList sign11 = sign(prikeys, transactionCapsule.getTransactionId().getBytes());
- builder1 = transactionCapsule.getInstance().toBuilder();
- builder1.addAllSignature(sign11);
- transactionCapsule = new TransactionCapsule(builder1.build());
-
- try {
- transactionCapsule.addSign(ByteArray.fromHexString(KEY_21), accountStore);
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertEquals(e.getMessage(),
- ByteArray.toHexString(sign11.get(0).toByteArray()) + " is signed by " + Wallet
- .encode58Check(ByteArray.fromHexString(KEY_ADDRESS_11))
- + " but it is not contained of permission.");
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- }
-
- @Test
- // test public static boolean validateSignature(Transaction.Contract contract,
- ByteString sigs, byte[] hash, AccountStore accountStore)
- public void validateSignature0() {
- //Update permission, can signed by key21 key22 key23
- AccountStore accountStore = dbManager.getAccountStore();
- List permissions = buildPermissions();
-
- byte[] to = ByteArray.fromHexString(TO_ADDRESS);
- byte[] owner_not_exist = ByteArray.fromHexString(OWNER_ACCOUNT_NOT_Exist);
- TransferContract transferContract = createTransferContract(to, owner_not_exist, 1);
- Transaction.Builder trxBuilder = Transaction
- .newBuilder();
- Transaction.raw.Builder rawBuilder = Transaction.raw.newBuilder();
- Contract.Builder contractBuilder = Contract.newBuilder();
- contractBuilder.setType(ContractType.TransferContract).setParameter(Any.pack(transferContract));
- rawBuilder.addContract(contractBuilder.build());
- trxBuilder.setRawData(rawBuilder.build());
- List prikeys = new ArrayList<>();
- prikeys.add(ByteArray.fromHexString(KEY_21));
- ArrayList sign = sign(prikeys, Sha256Hash.hash(rawBuilder.build().toByteArray()));
- trxBuilder.addAllSignature(sign);
-
- Account account = accountStore.get(ByteArray.fromHexString(OWNER_ADDRESS)).getInstance();
- Account.Builder builder = account.toBuilder();
- builder.clearPermissions();
- builder.addPermissions(permissions.get(0));
- builder.addPermissions(permissions.get(1));
- builder.addPermissions(permissions.get(2));
- accountStore.put(ByteArray.fromHexString(OWNER_ADDRESS), new AccountCapsule(builder.build()));
- byte[] hash = Sha256Hash.hash("test".getBytes());
-
- byte[] owner = ByteArray.fromHexString(OWNER_ADDRESS);
- transferContract = createTransferContract(to, owner, 1);
- contractBuilder = Contract.newBuilder();
- contractBuilder.setParameter(Any.pack(transferContract)).setType(ContractType.TransferContract);
- rawBuilder.clearContract().addContract(contractBuilder.build());
- trxBuilder.setRawData(rawBuilder.build());
-
- //SignatureFormatException
- ByteString test = ByteString.copyFromUtf8("test");
- trxBuilder.clearSignature().addSignature(test);
- try {
- TransactionCapsule.validateSignature(trxBuilder.build(), hash, accountStore);
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertEquals(e.getMessage(), "Signature size is " + test.size());
- }
- //SignatureException: Header byte out of range:
- //Ignore more exception case.
- byte[] rand = new byte[65];
- new Random().nextBytes(rand);
- rand[64] = 8; // v = 8 < 27 v += 35 > 35
- trxBuilder.clearSignature().addSignature(ByteString.copyFrom(rand));
- try {
- TransactionCapsule.validateSignature(trxBuilder.build(), hash,
- accountStore);
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertEquals(e.getMessage(), "Header byte out of range: 35");
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- //Permission is not contain KEY
- prikeys = new ArrayList<>();
- prikeys.clear();
- prikeys.add(ByteArray.fromHexString(KEY_21));
- prikeys.add(ByteArray.fromHexString(KEY_11));
- ArrayList sign21_11 = sign(prikeys, hash);
- trxBuilder.clearSignature().addAllSignature(sign21_11);
- try {
- TransactionCapsule.validateSignature(trxBuilder.build(), hash, accountStore);
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- ByteString sign21 = sign21_11.get(1);
- Assert.assertEquals(e.getMessage(),
- ByteArray.toHexString(sign21.toByteArray()) + " is signed by " + Wallet
- .encode58Check(ByteArray.fromHexString(KEY_ADDRESS_11))
- + " but it is not contained of permission.");
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- //Too many signature
- prikeys.add(ByteArray.fromHexString(KEY_22));
- prikeys.add(ByteArray.fromHexString(KEY_23));
- ArrayList sign21_11_22_23 = sign(prikeys, hash);
- trxBuilder.clearSignature().addAllSignature(sign21_11_22_23);
- try {
- TransactionCapsule
- .validateSignature(trxBuilder.build(), hash, accountStore);
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertEquals(e.getMessage(),
- "Signature count is " + prikeys.size() + " more than key counts of permission : "
- + permissions.get(1).getKeysCount());
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
-
- //Sign twices by same key
- prikeys = new ArrayList<>();
- prikeys.add(ByteArray.fromHexString(KEY_21));
- prikeys.add(ByteArray.fromHexString(KEY_22));
- prikeys.add(ByteArray.fromHexString(KEY_21));
- ArrayList sign21_22_21 = sign(prikeys, hash);
- trxBuilder.clearSignature().addAllSignature(sign21_22_21);
- try {
- TransactionCapsule
- .validateSignature(trxBuilder.build(), hash, accountStore);
- Assert.assertFalse(true);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertEquals(e.getMessage(),
- WalletUtil.encode58Check(ByteArray.fromHexString(KEY_ADDRESS_21)) + " has signed twice!");
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
-
- //
- prikeys = new ArrayList<>();
- prikeys.add(ByteArray.fromHexString(KEY_21));
- ArrayList sign21 = sign(prikeys, hash);
- trxBuilder.clearSignature().addAllSignature(sign21);
- try {
- boolean result = TransactionCapsule
- .validateSignature(trxBuilder.build(), hash, accountStore);
- Assert.assertFalse(result);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
-
- prikeys.add(ByteArray.fromHexString(KEY_22));
- ArrayList sign21_22 = sign(prikeys, hash);
- trxBuilder.clearSignature().addAllSignature(sign21_22);
- try {
- boolean result = TransactionCapsule
- .validateSignature(trxBuilder.build(), hash, accountStore);
- Assert.assertTrue(result);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
-
- prikeys.add(ByteArray.fromHexString(KEY_23));
- ArrayList sign21_22_23 = sign(prikeys, hash);
- trxBuilder.clearSignature().addAllSignature(sign21_22_23);
- try {
- boolean result = TransactionCapsule
- .validateSignature(trxBuilder.build(), hash, accountStore);
- Assert.assertTrue(result);
- } catch (SignatureException e) {
- Assert.assertFalse(true);
- } catch (PermissionException e) {
- Assert.assertFalse(true);
- } catch (SignatureFormatException e) {
- Assert.assertFalse(true);
- }
- }
-
- @Test
- // test public boolean validateSignature(AccountStore accountStore)
- public void validateSignature1() {
- //Update permission, can signed by key21 key22 key23
- List permissions = buildPermissions();
- Account account = dbManager.getAccountStore().get(ByteArray.fromHexString(OWNER_ADDRESS))
- .getInstance();
- Account.Builder builder = account.toBuilder();
- builder.clearPermissions();
- builder.addPermissions(permissions.get(0));
- builder.addPermissions(permissions.get(1));
- builder.addPermissions(permissions.get(2));
- dbManager.getAccountStore()
- .put(ByteArray.fromHexString(OWNER_ADDRESS), new AccountCapsule(builder.build()));
-
- byte[] to = ByteArray.fromHexString(TO_ADDRESS);
- byte[] owner_not_exist = ByteArray.fromHexString(OWNER_ACCOUNT_NOT_Exist);
- TransferContract transferContract = createTransferContract(to, owner_not_exist, 1);
- Transaction.Builder trxBuilder = Transaction.newBuilder();
- Transaction.raw.Builder rawBuilder = Transaction.raw.newBuilder();
- Contract.Builder contractBuilder = Contract.newBuilder();
- contractBuilder.setType(ContractType.TransferContract).setParameter(Any.pack(transferContract))
- .build();
- rawBuilder.addContract(contractBuilder);
- trxBuilder.setRawData(rawBuilder);
- TransactionCapsule transactionCapsule = new TransactionCapsule(trxBuilder.build());
- List prikeys = new ArrayList<>();
- prikeys.add(ByteArray.fromHexString(KEY_21));
- ArrayList sign = sign(prikeys, Sha256Hash.hash(rawBuilder.build().toByteArray()));
- trxBuilder.addAllSignature(sign);
- transactionCapsule = new TransactionCapsule(trxBuilder.build());
-
- // no contract
- prikeys.clear();
- prikeys.add(ByteArray.fromHexString(KEY_21));
- trxBuilder = Transaction.newBuilder();
- rawBuilder = Transaction.raw.newBuilder();
- rawBuilder.setTimestamp(System.currentTimeMillis());
- trxBuilder.setRawData(rawBuilder);
- sign = sign(prikeys, Sha256Hash.hash(rawBuilder.build().toByteArray()));
- trxBuilder.addAllSignature(sign);
- transactionCapsule = new TransactionCapsule(trxBuilder.build());
- try {
- transactionCapsule.validateSignature(dbManager);
- Assert.assertFalse(true);
- } catch (ValidateSignatureException e) {
- Assert.assertEquals(e.getMessage(), "miss sig or contract");
- }
- // no sign
- byte[] owner = ByteArray.fromHexString(OWNER_ADDRESS);
- transferContract = createTransferContract(to, owner, 1);
- transactionCapsule = new TransactionCapsule(transferContract, dbManager.getAccountStore());
- try {
- transactionCapsule.validateSignature(dbManager);
- Assert.assertFalse(true);
- } catch (ValidateSignatureException e) {
- Assert.assertEquals(e.getMessage(), "miss sig or contract");
- }
-
- transactionCapsule = new TransactionCapsule(transferContract, dbManager.getAccountStore());
- byte[] hash = transactionCapsule.getTransactionId().getBytes();
- trxBuilder = transactionCapsule.getInstance().toBuilder();
- //SignatureFormatException
- ByteString test = ByteString.copyFromUtf8("test");
- trxBuilder.clearSignature();
- trxBuilder.addSignature(test);
- transactionCapsule = new TransactionCapsule(trxBuilder.build());
- try {
- transactionCapsule.validateSignature(dbManager);
- Assert.assertFalse(true);
- } catch (ValidateSignatureException e) {
- Assert.assertEquals(e.getMessage(), "Signature size is " + test.size());
- }
- //SignatureException: Header byte out of range:
- //Ignore more exception case.
- byte[] rand = new byte[65];
- new Random().nextBytes(rand);
- rand[64] = 8; // v = 8 < 27 v += 35 > 35
- trxBuilder.clearSignature();
- trxBuilder.addSignature(ByteString.copyFrom(rand));
- transactionCapsule = new TransactionCapsule(trxBuilder.build());
- try {
- transactionCapsule.validateSignature(dbManager);
- Assert.assertFalse(true);
- } catch (ValidateSignatureException e) {
- Assert.assertEquals(e.getMessage(), "Header byte out of range: 35");
- }
- //Permission is not contain KEY
- prikeys.clear();
- prikeys.add(ByteArray.fromHexString(KEY_21));
- prikeys.add(ByteArray.fromHexString(KEY_11));
- ArrayList