feat(test): refactor codes

Author: Liulei

framework/src/main/java/org/tron/core/zen/KZGPointEvaluationInitService.java

@@ -3,36 +3,42 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.concurrent.atomic.AtomicBoolean;
 import javax.annotation.PostConstruct;
-
-import org.tron.common.crypto.ckzg4844.CKZG4844JNI;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.io.FileUtils;
 import org.springframework.stereotype.Component;
+import org.tron.common.crypto.ckzg4844.CKZG4844JNI;
 
 @Slf4j
 @Component
 public class KZGPointEvaluationInitService {
 
+  private static final AtomicBoolean loaded = new AtomicBoolean(false);
+
   @PostConstruct
   private void init() {
     initCKZG4844();
   }
 
   public static void freeSetup() {
-    CKZG4844JNI.freeTrustedSetup();
+    if (loaded.compareAndSet(true, false)) {
+      CKZG4844JNI.freeTrustedSetup();
+    }
   }
 
   public static void initCKZG4844() {
-    logger.info("init ckzg 4844 begin");
+    if (loaded.compareAndSet(false, true)) {
+      logger.info("init ckzg 4844 begin");
 
-    CKZG4844JNI.loadNativeLibrary();
+      CKZG4844JNI.loadNativeLibrary();
 
-    String setupFile = getSetupFile("trusted_setup.txt");
+      String setupFile = getSetupFile("trusted_setup.txt");
 
-    CKZG4844JNI.loadTrustedSetup(setupFile, 0);
+      CKZG4844JNI.loadTrustedSetup(setupFile, 0);
 
-    logger.info("init ckzg 4844 done");
+      logger.info("init ckzg 4844 done");
+    }
   }
 
   private static String getSetupFile(String fileName) {

framework/src/test/java/org/tron/common/runtime/vm/PrecompiledContractsTest.java

@@ -40,8 +40,6 @@
 import org.tron.core.vm.config.VMConfig;
 import org.tron.core.vm.repository.Repository;
 import org.tron.core.vm.repository.RepositoryImpl;
-import org.tron.core.zen.KZGPointEvaluationInitService;
-import org.tron.core.zen.ZksnarkInitService;
 import org.tron.protos.Protocol;
 import org.tron.protos.Protocol.AccountType;
 import org.tron.protos.Protocol.Proposal.State;
@@ -1179,13 +1177,14 @@ public void kzgPointEvaluationTest() {
     Repository tempRepository = RepositoryImpl.createRoot(StoreFactory.getInstance());
     contract.setRepository(tempRepository);
 
-    byte[] versionedHash = Hex.decode("015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68");
+    byte[] versionedHash =
+        Hex.decode("015a4cab4911426699ed34483de6640cf55a568afc5c5edffdcbd8bcd4452f68");
     byte[] z = Hex.decode("0000000000000000000000000000000000000000000000000000000000000065");
     byte[] y = Hex.decode("60f557194475973322b33dc989896381844508234bfa6fbeefe5fa165ae15a0a");
-    byte[] commitment = Hex.decode("a70477b56251e8770969c83eaed665d3ab99b96b72270a4" +
-        "1009f2752b5c06a06bd089ad48952c12b1dbf83dccd9d373f");
-    byte[] proof = Hex.decode("879f9a41956deae578bc65e7133f164394b8677bc2e7b1356be61" +
-        "d47720ed2a3326bfddebc67cd37ee9e7537d7814afe");
+    byte[] commitment = Hex.decode("a70477b56251e8770969c83eaed665d3ab99b96b72270a4"
+        + "1009f2752b5c06a06bd089ad48952c12b1dbf83dccd9d373f");
+    byte[] proof = Hex.decode("879f9a41956deae578bc65e7133f164394b8677bc2e7b1356be61"
+        + "d47720ed2a3326bfddebc67cd37ee9e7537d7814afe");
 
     byte[] data = new byte[192];
     System.arraycopy(versionedHash, 0, data, 0, 32);
@@ -1213,8 +1212,8 @@ public void kzgPointEvaluationTest() {
 
     res = contract.execute(data);
     byte[] expected = Hex.decode(
-      "0000000000000000000000000000000000000000000000000000000000001000" +
-          "73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001");
+      "0000000000000000000000000000000000000000000000000000000000001000"
+          + "73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001");
     Assert.assertTrue(res.getLeft());
     Assert.assertArrayEquals(expected, res.getRight());
     VMConfig.initAllowTvmBlob(0);

framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java

@@ -435,6 +435,10 @@ public void validateCheck() {
 
     testConsensusLogicOptimizationProposal();
 
+    testAllowTvmCancunProposal();
+
+    testAllowTvmBlobProposal();
+
     forkUtils.getManager().getDynamicPropertiesStore()
         .statsByVersion(ForkBlockVersionEnum.ENERGY_LIMIT.getValue(), stats);
     forkUtils.reset();
@@ -551,6 +555,110 @@ private void testConsensusLogicOptimizationProposal() {
 
   }
 
+  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()) {

framework/src/test/java/org/tron/core/zksnark/KZGPointEvaluationTest.java

@@ -1,14 +1,16 @@
 package org.tron.core.zksnark;
 
+import java.util.Arrays;
 import lombok.extern.slf4j.Slf4j;
 import org.bouncycastle.util.encoders.Hex;
+import org.junit.Assert;
 import org.junit.Test;
 import org.tron.common.crypto.ckzg4844.CKZG4844JNI;
+import org.tron.common.crypto.ckzg4844.CKZGException;
+import org.tron.common.crypto.ckzg4844.CellsAndProofs;
+import org.tron.common.crypto.ckzg4844.ProofAndY;
 import org.tron.core.zen.KZGPointEvaluationInitService;
 
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertTrue;
-
 @Slf4j
 public class KZGPointEvaluationTest {
 
@@ -22,16 +24,59 @@ public void testVerifyBlobKzgProof() {
     byte[] expectedCommitment =
         Hex.decode("a70477b56251e8770969c83eaed665d3ab99b96b72270a41009f27"
             + "52b5c06a06bd089ad48952c12b1dbf83dccd9d373f");
-    assertArrayEquals(expectedCommitment, commitment);
+    Assert.assertArrayEquals(expectedCommitment, commitment);
 
     byte[] proof = CKZG4844JNI.computeBlobKzgProof(blob, commitment);
     byte[] expectedProof =
         Hex.decode("b7f576f2442febaa035d3c6f34bbdad6acebcaec70236ff40b3373b"
             + "d2ca00547d3ca7bb1d0ed3e728ca9dab610a4cfa4");
-    assertArrayEquals(expectedProof, proof);
+    Assert.assertArrayEquals(expectedProof, proof);
 
     boolean isValidProof = CKZG4844JNI.verifyBlobKzgProof(blob, commitment, proof);
-    assertTrue(isValidProof);
+    Assert.assertTrue(isValidProof);
+
+    byte[] z =
+        Hex.decode("0000000000000000000000000000000000000000000000000000000000000065");
+    byte[] y =
+        Hex.decode("60f557194475973322b33dc989896381844508234bfa6fbeefe5fa165ae15a0a");
+    ProofAndY proofAndY = CKZG4844JNI.computeKzgProof(blob, z);
+    byte[] expectedZProof =
+        Hex.decode("879f9a41956deae578bc65e7133f164394b8677bc2e7b1356be61"
+            + "d47720ed2a3326bfddebc67cd37ee9e7537d7814afe");
+    Assert.assertArrayEquals(y, proofAndY.getY());
+    Assert.assertArrayEquals(expectedZProof, proofAndY.getProof());
+
+    CellsAndProofs cellsAndProofs = CKZG4844JNI.computeCellsAndKzgProofs(blob);
+    byte[] blockCells = Arrays.copyOfRange(cellsAndProofs.getCells(), 0, 2048);
+    byte[] blockProof = Arrays.copyOfRange(cellsAndProofs.getProofs(), 0, 48);
+    long[] cellIndices = new long[1];
+    boolean isValid =
+        CKZG4844JNI.verifyCellKzgProofBatch(commitment, cellIndices, blockCells, blockProof);
+    Assert.assertTrue(isValid);
+
+    long[] errorCellIndices = new long[2];
+    errorCellIndices[1] = 1;
+    CKZGException expectedE = new CKZGException(1,
+        "Invalid cellIndices size. Expected 1 bytes but got 2.");
+    try {
+      CKZG4844JNI.verifyCellKzgProofBatch(commitment, errorCellIndices, blockCells, blockProof);
+    } catch (Exception e) {
+      Assert.assertEquals(CKZGException.class, e.getClass());
+      CKZGException exception = (CKZGException) e;
+      Assert.assertEquals(expectedE.getError(), exception.getError());
+      Assert.assertEquals(expectedE.getErrorMessage(), exception.getErrorMessage());
+    }
+
+    try {
+      String testSetupResource = "/kzg-trusted-setups/test.txt";
+      CKZG4844JNI.loadTrustedSetupFromResource(
+          testSetupResource, KZGPointEvaluationTest.class, 0);
+    } catch (Exception e) {
+      Assert.assertEquals(RuntimeException.class, e.getClass());
+      Assert.assertEquals(
+          "Trusted Setup is already loaded. Free it before loading a new one.",
+          e.getMessage());
+    }
 
     KZGPointEvaluationInitService.freeSetup();
   }