Default result size

src/main/java/org/tron/core/Constant.java

@@ -52,6 +52,7 @@ public class Constant {
   public static final long STORAGE_LIMIT_IN_ONE_TX_OF_SMART_CONTRACT = 32 * 1024 * 1024L; // 32MB
   public static final long SUN_PER_ENERGY = 100; // 1 us = 100 DROP = 100 * 10^-6 TRX
   public static final long MAX_ENERGY_IN_TX = 3000000; // ref: 1 us = 1 energy
+  public static final long MAX_RESULT_SIZE_IN_TX = 64; // max 8 * 8 items in result
   public static final long MAX_CONSUME_USER_RESOURCE_PERCENT = 100L;
   public static final long MIN_CONSUME_USER_RESOURCE_PERCENT = 0L;
   public static final long ACCORD_RANGE_PERCENT = 0L;

src/main/java/org/tron/core/Wallet.java

@@ -407,7 +407,9 @@ public GrpcAPI.Return broadcastTransaction(Transaction signaturedTransaction) {
       } else {
         dbManager.getTransactionIdCache().put(trx.getTransactionId(), true);
       }
-
+      if (dbManager.getDynamicPropertiesStore().supportVM()) {
+        trx.resetResult();
+      }
       dbManager.pushTransaction(trx);
       p2pNode.broadcast(message);
 

src/main/java/org/tron/core/capsule/TransactionCapsule.java

@@ -485,6 +485,14 @@ public long getSerializedSize() {
     return this.transaction.getSerializedSize();
   }
 
+  public long getResultSerializedSize() {
+    long size = 0;
+    for (Result result : this.transaction.getRetList()) {
+      size += result.getSerializedSize();
+    }
+    return size;
+  }
+
   @Override
   public Transaction getInstance() {
     return this.transaction;

src/main/java/org/tron/core/db/BandwidthProcessor.java

@@ -8,12 +8,14 @@
 import java.util.Map;
 import lombok.extern.slf4j.Slf4j;
 import org.tron.common.utils.ByteArray;
+import org.tron.core.Constant;
 import org.tron.core.capsule.AccountCapsule;
 import org.tron.core.capsule.AssetIssueCapsule;
 import org.tron.core.capsule.TransactionCapsule;
 import org.tron.core.capsule.TransactionResultCapsule;
 import org.tron.core.exception.AccountResourceInsufficientException;
 import org.tron.core.exception.ContractValidateException;
+import org.tron.core.exception.TooBigTransactionResultException;
 import org.tron.protos.Contract.TransferAssetContract;
 import org.tron.protos.Contract.TransferContract;
 import org.tron.protos.Protocol.Transaction.Contract;
@@ -50,13 +52,21 @@ private void updateUsage(AccountCapsule accountCapsule, long now) {
   @Override
   public void consume(TransactionCapsule trx, TransactionResultCapsule ret,
       TransactionTrace trace)
-      throws ContractValidateException, AccountResourceInsufficientException {
-    List<Contract> contracts =
-        trx.getInstance().getRawData().getContractList();
-    TransactionCapsule transactionCapsule = new TransactionCapsule(trx.getInstance().getRawData(),
-        trx.getInstance().getSignatureList());
+      throws ContractValidateException, AccountResourceInsufficientException, TooBigTransactionResultException {
+    List<Contract> contracts = trx.getInstance().getRawData().getContractList();
+    if (trx.getResultSerializedSize() > Constant.MAX_RESULT_SIZE_IN_TX * contracts.size()) {
+      throw new TooBigTransactionResultException();
+    }
     for (Contract contract : contracts) {
-      long bytes = transactionCapsule.getSerializedSize();
+      long bytes = 0;
+      if (dbManager.getDynamicPropertiesStore().supportVM()) {
+        TransactionCapsule txCapForEstimateBandWidth = new TransactionCapsule(
+            trx.getInstance().getRawData(),
+            trx.getInstance().getSignatureList());
+        bytes = txCapForEstimateBandWidth.getSerializedSize() + Constant.MAX_RESULT_SIZE_IN_TX;
+      } else {
+        bytes = trx.getSerializedSize();
+      }
       logger.debug("trxId {},bandwidth cost :{}", trx.getTransactionId(), bytes);
       trace.setNetBill(bytes, 0);
       byte[] address = TransactionCapsule.getOwner(contract);

src/main/java/org/tron/core/db/Manager.java

@@ -39,7 +39,6 @@
 import org.springframework.stereotype.Component;
 import org.tron.common.overlay.discover.node.Node;
 import org.tron.common.runtime.Runtime;
-import org.tron.common.runtime.config.SystemProperties;
 import org.tron.common.runtime.vm.program.invoke.ProgramInvokeFactoryImpl;
 import org.tron.common.storage.DepositImpl;
 import org.tron.common.utils.ByteArray;
@@ -82,6 +81,7 @@
 import org.tron.core.exception.ReceiptException;
 import org.tron.core.exception.TaposException;
 import org.tron.core.exception.TooBigTransactionException;
+import org.tron.core.exception.TooBigTransactionResultException;
 import org.tron.core.exception.TransactionExpirationException;
 import org.tron.core.exception.TransactionTraceException;
 import org.tron.core.exception.UnLinkedBlockException;
@@ -585,7 +585,7 @@ public boolean pushTransaction(final TransactionCapsule trx)
       throws ValidateSignatureException, ContractValidateException, ContractExeException,
       AccountResourceInsufficientException, DupTransactionException, TaposException,
       TooBigTransactionException, TransactionExpirationException, ReceiptException,
-      TransactionTraceException, ReceiptCheckErrException, UnsupportVMException {
+      TransactionTraceException, ReceiptCheckErrException, UnsupportVMException, TooBigTransactionResultException {
 
     if (!trx.validateSignature()) {
       throw new ValidateSignatureException("trans sig validate failed");
@@ -609,7 +609,7 @@ public boolean pushTransaction(final TransactionCapsule trx)
 
   public void consumeBandwidth(TransactionCapsule trx, TransactionResultCapsule ret,
       TransactionTrace trace)
-      throws ContractValidateException, AccountResourceInsufficientException {
+      throws ContractValidateException, AccountResourceInsufficientException, TooBigTransactionResultException {
     BandwidthProcessor processor = new BandwidthProcessor(this);
     processor.consume(trx, ret, trace);
   }
@@ -680,7 +680,7 @@ private void applyBlock(BlockCapsule block) throws ContractValidateException,
       ContractExeException, ValidateSignatureException, AccountResourceInsufficientException,
       TransactionExpirationException, TooBigTransactionException, DupTransactionException, ReceiptException,
       TaposException, ValidateScheduleException, TransactionTraceException, ReceiptCheckErrException,
-      UnsupportVMException {
+      UnsupportVMException, TooBigTransactionResultException {
     processBlock(block);
     this.blockStore.put(block.getBlockId().getBytes(), block);
     this.blockIndexStore.put(block.getBlockId());
@@ -690,7 +690,7 @@ private void applyBlock(BlockCapsule block) throws ContractValidateException,
   private void switchFork(BlockCapsule newHead)
       throws ValidateSignatureException, ContractValidateException, ContractExeException,
       ValidateScheduleException, AccountResourceInsufficientException, TaposException,
-      TooBigTransactionException, DupTransactionException, TransactionExpirationException,
+      TooBigTransactionException, TooBigTransactionResultException, DupTransactionException, TransactionExpirationException,
       NonCommonBlockException, ReceiptException, TransactionTraceException, ReceiptCheckErrException,
       UnsupportVMException {
     Pair<LinkedList<KhaosBlock>, LinkedList<KhaosBlock>> binaryTree;
@@ -737,6 +737,7 @@ private void switchFork(BlockCapsule newHead)
             | ReceiptException
             | ReceiptCheckErrException
             | TooBigTransactionException
+            | TooBigTransactionResultException
             | ValidateScheduleException
             | UnsupportVMException e) {
           logger.warn(e.getMessage(), e);
@@ -792,7 +793,7 @@ private synchronized void filterPendingTrx(List<TransactionCapsule> listTrx) {
   public synchronized void pushBlock(final BlockCapsule block)
       throws ValidateSignatureException, ContractValidateException, ContractExeException,
       UnLinkedBlockException, ValidateScheduleException, AccountResourceInsufficientException,
-      TaposException, TooBigTransactionException, DupTransactionException, TransactionExpirationException,
+      TaposException, TooBigTransactionException, TooBigTransactionResultException, DupTransactionException, TransactionExpirationException,
       BadNumberBlockException, BadBlockException, NonCommonBlockException, ReceiptException, TransactionTraceException,
       ReceiptCheckErrException, UnsupportVMException {
     try (PendingManager pm = new PendingManager(this)) {
@@ -1006,7 +1007,7 @@ public boolean hasBlocks() {
    */
   public boolean processTransaction(final TransactionCapsule trxCap, BlockCapsule blockCap)
       throws ValidateSignatureException, ContractValidateException, ContractExeException, ReceiptException,
-      AccountResourceInsufficientException, TransactionExpirationException, TooBigTransactionException,
+      AccountResourceInsufficientException, TransactionExpirationException, TooBigTransactionException, TooBigTransactionResultException,
       DupTransactionException, TaposException, TransactionTraceException, ReceiptCheckErrException, UnsupportVMException {
     if (trxCap == null) {
       return false;
@@ -1040,7 +1041,7 @@ public boolean processTransaction(final TransactionCapsule trxCap, BlockCapsule
       // Fixme Wrong exception
       throw new UnsupportVMException("cannot call constant method ");
     }
-    // if (SystemProperties.getInstance().vmOn()) {
+    // if (getDynamicPropertiesStore().supportVM()) {
     //   if(trxCap.getInstance().getRetCount()<=0){
     //     trxCap.setResult(new TransactionResultCapsule(contractResult.UNKNOWN));
     //   }
@@ -1068,7 +1069,7 @@ public boolean processTransaction(final TransactionCapsule trxCap, BlockCapsule
 
     trace.finalization(runtime);
     if (Objects.nonNull(blockCap)) {
-      if (SystemProperties.getInstance().vmOn()) {
+      if (getDynamicPropertiesStore().supportVM()) {
         trxCap.setResult(runtime);
       }
     }
@@ -1159,6 +1160,9 @@ public synchronized BlockCapsule generateBlock(
       } catch (TooBigTransactionException e) {
         logger.info("contract not processed during TooBigTransactionException");
         logger.debug(e.getMessage(), e);
+      } catch (TooBigTransactionResultException e) {
+        logger.info("contract not processed during TooBigTransactionResultException");
+        logger.debug(e.getMessage(), e);
       } catch (TransactionExpirationException e) {
         logger.info("contract not processed during TransactionExpirationException");
         logger.debug(e.getMessage(), e);
@@ -1216,6 +1220,8 @@ public synchronized BlockCapsule generateBlock(
       logger.debug(e.getMessage(), e);
     } catch (UnsupportVMException e) {
       logger.warn(e.getMessage(), e);
+    } catch (TooBigTransactionResultException e) {
+      logger.info("contract not processed during TooBigTransactionResultException");
     }
 
     return null;
@@ -1256,7 +1262,7 @@ public void processBlock(BlockCapsule block)
       throws ValidateSignatureException, ContractValidateException, ContractExeException,
       AccountResourceInsufficientException, TaposException, TooBigTransactionException,
       DupTransactionException, TransactionExpirationException, ValidateScheduleException,
-      ReceiptException, TransactionTraceException, ReceiptCheckErrException, UnsupportVMException {
+      ReceiptException, TransactionTraceException, ReceiptCheckErrException, UnsupportVMException, TooBigTransactionResultException {
     // todo set revoking db max size.
 
     // checkWitness
@@ -1582,6 +1588,8 @@ public void rePush(TransactionCapsule tx) {
       logger.debug("outOfSlotTime transaction");
     } catch (UnsupportVMException e) {
       logger.debug(e.getMessage(), e);
+    } catch (TooBigTransactionResultException e) {
+      logger.debug("too big transaction result");
     }
   }
 }

src/main/java/org/tron/core/db/ResourceProcessor.java

@@ -7,6 +7,7 @@
 import org.tron.core.exception.AccountResourceInsufficientException;
 import org.tron.core.exception.BalanceInsufficientException;
 import org.tron.core.exception.ContractValidateException;
+import org.tron.core.exception.TooBigTransactionResultException;
 
 abstract class ResourceProcessor {
 
@@ -24,7 +25,7 @@ public ResourceProcessor(Manager manager) {
 
   abstract void consume(TransactionCapsule trx, TransactionResultCapsule ret,
       TransactionTrace trace)
-      throws ContractValidateException, AccountResourceInsufficientException;
+      throws ContractValidateException, AccountResourceInsufficientException, TooBigTransactionResultException;
 
   protected long increase(long lastUsage, long usage, long lastTime, long now) {
     long averageLastUsage = divideCeil(lastUsage * precision, windowSize);

src/main/java/org/tron/core/exception/TooBigTransactionResultException.java

@@ -0,0 +1,8 @@
+package org.tron.core.exception;
+
+public class TooBigTransactionResultException extends TronException {
+
+    public TooBigTransactionResultException() { super("too big transaction result"); }
+
+    public TooBigTransactionResultException(String message) { super(message); }
+}

src/main/java/org/tron/core/net/message/TransactionMessage.java

@@ -1,5 +1,6 @@
 package org.tron.core.net.message;
 
+import org.tron.common.runtime.config.SystemProperties;
 import org.tron.common.utils.Sha256Hash;
 import org.tron.core.capsule.TransactionCapsule;
 import org.tron.core.exception.BadItemException;
@@ -38,7 +39,6 @@ public Class<?> getAnswerMessage() {
   }
 
   public TransactionCapsule getTransactionCapsule() {
-    //this.transactionCapsule.resetResult();
     return this.transactionCapsule;
   }
 }

src/main/java/org/tron/core/net/node/NodeDelegateImpl.java

@@ -35,6 +35,7 @@
 import org.tron.core.exception.StoreException;
 import org.tron.core.exception.TaposException;
 import org.tron.core.exception.TooBigTransactionException;
+import org.tron.core.exception.TooBigTransactionResultException;
 import org.tron.core.exception.TransactionExpirationException;
 import org.tron.core.exception.TransactionTraceException;
 import org.tron.core.exception.TronException;
@@ -97,6 +98,8 @@ public synchronized LinkedList<Sha256Hash> handleBlock(BlockCapsule block, boole
       throw new BadBlockException("DupTransaction exception," + e.getMessage());
     } catch (TooBigTransactionException e) {
       throw new BadBlockException("TooBigTransaction exception," + e.getMessage());
+    } catch (TooBigTransactionResultException e) {
+      throw new BadBlockException("TooBigTransaction exception," + e.getMessage());
     } catch (TransactionExpirationException e) {
       throw new BadBlockException("Expiration exception," + e.getMessage());
     } catch (ReceiptException e) {
@@ -116,6 +119,9 @@ public synchronized LinkedList<Sha256Hash> handleBlock(BlockCapsule block, boole
 
   @Override
   public boolean handleTransaction(TransactionCapsule trx) throws BadTransactionException {
+    if (dbManager.getDynamicPropertiesStore().supportVM()) {
+      trx.resetResult();
+    }
     logger.debug("handle transaction");
     if (dbManager.getTransactionIdCache().getIfPresent(trx.getTransactionId()) != null) {
       logger.warn("This transaction has been processed");
@@ -165,6 +171,9 @@ public boolean handleTransaction(TransactionCapsule trx) throws BadTransactionEx
     } catch (UnsupportVMException e) {
       logger.warn(e.getMessage());
       return false;
+    } catch (TooBigTransactionResultException e) {
+      logger.info("too big transactionresult" + e.getMessage());
+      return false;
     }
 
     return true;