feat(vm): add optimized BN128 precompiled contracts via IPC

actuator/src/main/java/org/tron/core/utils/ProposalUtil.java

@@ -871,6 +871,21 @@ public static void validator(DynamicPropertiesStore dynamicPropertiesStore,
         }
         break;
       }
+      case ALLOW_OPTIMIZED_BN128: {
+        if (!forkController.pass(ForkBlockVersionEnum.VERSION_4_8_2)) {
+          throw new ContractValidateException(
+              "Bad chain parameter id [ALLOW_OPTIMIZED_BN128]");
+        }
+        if (dynamicPropertiesStore.getAllowOptimizedBN128() == 1) {
+          throw new ContractValidateException(
+              "[ALLOW_OPTIMIZED_BN128] has been valid, no need to propose again");
+        }
+        if (value != 1) {
+          throw new ContractValidateException(
+              "This value[ALLOW_OPTIMIZED_BN128] is only allowed to be 1");
+        }
+        break;
+      }
       default:
         break;
     }
@@ -955,7 +970,8 @@ public enum ProposalType {         // current value, value range
     CONSENSUS_LOGIC_OPTIMIZATION(88), // 0, 1
     ALLOW_TVM_BLOB(89), // 0, 1
     PROPOSAL_EXPIRE_TIME(92), // (0, 31536003000)
-    ALLOW_TVM_SELFDESTRUCT_RESTRICTION(94); // 0, 1
+    ALLOW_TVM_SELFDESTRUCT_RESTRICTION(94), // 0, 1
+    ALLOW_OPTIMIZED_BN128(95); // 0, 1
 
     private long code;
 

actuator/src/main/java/org/tron/core/vm/PrecompiledContracts.java

@@ -45,6 +45,8 @@
 import org.tron.common.crypto.Rsv;
 import org.tron.common.crypto.SignUtils;
 import org.tron.common.crypto.SignatureInterface;
+import org.tron.common.crypto.bn128.BN128Service;
+import org.tron.common.crypto.bn128.SocketBN128Client;
 import org.tron.common.crypto.zksnark.BN128;
 import org.tron.common.crypto.zksnark.BN128Fp;
 import org.tron.common.crypto.zksnark.BN128G1;
@@ -426,6 +428,39 @@ public abstract static class PrecompiledContract {
     @Getter
     @Setter
     private long vmShouldEndInUs;
+    protected static BN128Service client;
+    // BN128 client connection pool size
+    private static final int BN128_CLIENT_POOL_SIZE = 8;
+
+    static {
+      if (VMConfig.allowOptimizedBn128()) {
+        try {
+          int bn128Port = VMConfig.getBN128ClientPort();
+          int bn128Timeout = VMConfig.getBN128SocketTimeout();
+          client = new SocketBN128Client(BN128_CLIENT_POOL_SIZE, bn128Port, bn128Timeout);
+          logger.info("SocketBn128Client initialized with pool size={}, port={}, timeout={}ms",
+              BN128_CLIENT_POOL_SIZE, bn128Port, bn128Timeout);
+
+          // Register shutdown hook for graceful cleanup
+          Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+            try {
+              if (client != null) {
+                logger.info("Closing SocketBn128Client...");
+                client.close();
+                logger.info("SocketBn128Client closed successfully");
+              }
+            } catch (Exception e) {
+              logger.error("Error occurred while closing SocketBn128Client", e);
+            }
+          }));
+        } catch (Exception e) {
+          logger.warn(
+              "Failed to initialize SocketBn128Client, falling back to non-optimized mode: {}",
+              e.getMessage());
+          client = null;
+        }
+      }
+    }
 
     public abstract long getEnergyForData(byte[] data);
 
@@ -757,6 +792,18 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
         data = EMPTY_BYTE_ARRAY;
       }
 
+      if (VMConfig.allowOptimizedBn128() && client != null) {
+        byte[] input = data.length > 128 ? Arrays.copyOfRange(data, 0, 128) : data;
+        try {
+          return client.bn128Add(input);
+        } catch (Exception e) {
+          logger.warn(
+              "Optimized BN128 add failed for input length {}, falling back to non-optimized "
+                  + "implementation: {}",
+              data.length, e.getMessage());
+        }
+      }
+
       byte[] x1 = parseWord(data, 0);
       byte[] y1 = parseWord(data, 1);
 
@@ -811,6 +858,18 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
         data = EMPTY_BYTE_ARRAY;
       }
 
+      if (VMConfig.allowOptimizedBn128() && client != null) {
+        byte[] input = data.length > 96 ? Arrays.copyOfRange(data, 0, 96) : data;
+        try {
+          return client.bn128Mul(input);
+        } catch (Exception e) {
+          logger.warn(
+              "Optimized BN128 multiplication failed for input length {}, falling back to "
+                  + "non-optimized implementation: {}",
+              data.length, e.getMessage());
+        }
+      }
+
       byte[] x = parseWord(data, 0);
       byte[] y = parseWord(data, 1);
 
@@ -844,7 +903,8 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
   public static class BN128Pairing extends PrecompiledContract {
 
     private static final int PAIR_SIZE = 192;
-
+    // Limit to 100 pairs (19,200 bytes) in optimized mode to guarantee security
+    private static final int MAX_PAIR_SIZE_LIMIT = 192 * 100;
     @Override
     public long getEnergyForData(byte[] data) {
       if (VMConfig.allowTvmIstanbul()) {
@@ -875,6 +935,17 @@ public Pair<Boolean, byte[]> execute(byte[] data) {
         return Pair.of(false, EMPTY_BYTE_ARRAY);
       }
 
+      if (VMConfig.allowOptimizedBn128() && client != null && data.length <= MAX_PAIR_SIZE_LIMIT) {
+        try {
+          return client.bn128Pairing(data);
+        } catch (Exception e) {
+          logger.warn(
+              "Optimized BN128 pairing failed for input length {}, falling back to "
+                  + "non-optimized implementation: {}",
+              data.length, e.getMessage());
+        }
+      }
+
       PairingCheck check = PairingCheck.create();
 
       // iterating over all pairs

actuator/src/main/java/org/tron/core/vm/config/ConfigLoader.java

@@ -45,6 +45,9 @@ public static void load(StoreFactory storeFactory) {
         VMConfig.initDisableJavaLangMath(ds.getConsensusLogicOptimization());
         VMConfig.initAllowTvmBlob(ds.getAllowTvmBlob());
         VMConfig.initAllowTvmSelfdestructRestriction(ds.getAllowTvmSelfdestructRestriction());
+        VMConfig.initAllowOptimizedBN128(ds.getAllowOptimizedBN128());
+        VMConfig.initBN128Port(ds.getBN128Port());
+        VMConfig.initBN128SocketTimeout(ds.getBN128SocketTimeout());
       }
     }
   }

chainbase/src/main/java/org/tron/core/store/DynamicPropertiesStore.java

@@ -238,6 +238,9 @@ public class DynamicPropertiesStore extends TronStoreWithRevoking<BytesCapsule>
   private static final byte[] ALLOW_TVM_SELFDESTRUCT_RESTRICTION =
       "ALLOW_TVM_SELFDESTRUCT_RESTRICTION".getBytes();
 
+  private static final byte[] ALLOW_OPTIMIZED_BN128 =
+      "ALLOW_OPTIMIZED_BN128".getBytes();
+
   @Autowired
   private DynamicPropertiesStore(@Value("properties") String dbName) {
     super(dbName);
@@ -2967,7 +2970,32 @@ public void saveAllowTvmSelfdestructRestriction(long value) {
   public boolean allowTvmSelfdestructRestriction() {
     return getAllowTvmSelfdestructRestriction() == 1L;
   }
-
+
+  public void saveAllowOptimizedBn128(long allowOptimizedBn128) {
+    this.put(ALLOW_OPTIMIZED_BN128,
+        new BytesCapsule(ByteArray.fromLong(allowOptimizedBn128)));
+  }
+
+  public long getAllowOptimizedBN128() {
+    return Optional.ofNullable(getUnchecked(ALLOW_OPTIMIZED_BN128))
+        .map(BytesCapsule::getData)
+        .map(ByteArray::toLong)
+        .orElse(CommonParameter.getInstance()
+            .getAllowOptimizedBN128());
+  }
+
+  public boolean allowOptimizedBN128() {
+    return getAllowOptimizedBN128() == 1L;
+  }
+
+  public int getBN128Port() {
+    return CommonParameter.getInstance().getBn128ServerPort();
+  }
+
+  public int getBN128SocketTimeout() {
+    return CommonParameter.getInstance().getBn128SocketTimeout();
+  }
+
   public void saveProposalExpireTime(long proposalExpireTime) {
     this.put(PROPOSAL_EXPIRE_TIME, new BytesCapsule(ByteArray.fromLong(proposalExpireTime)));
   }

common/src/main/java/org/tron/common/parameter/CommonParameter.java

@@ -632,6 +632,18 @@ public class CommonParameter {
   @Getter
   @Setter
   public long allowTvmBlob;
+  @Getter
+  @Setter
+  public long allowOptimizedBN128;
+  @Getter
+  @Setter
+  public boolean launchBN128Server = false;
+  @Getter
+  @Setter
+  public int bn128ServerPort = 9001;
+  @Getter
+  @Setter
+  public int bn128SocketTimeout = 30;
 
   private static double calcMaxTimeRatio() {
     return 5.0;

common/src/main/java/org/tron/core/config/Parameter.java

@@ -28,7 +28,8 @@ public enum ForkBlockVersionEnum {
     VERSION_4_7_7(31, 1596780000000L, 80),
     VERSION_4_8_0(32, 1596780000000L, 80),
     VERSION_4_8_0_1(33, 1596780000000L, 70),
-    VERSION_4_8_1(34, 1596780000000L, 80);
+    VERSION_4_8_1(34, 1596780000000L, 80),
+    VERSION_4_8_2(35, 1596780000000L, 80);
     // if add a version, modify BLOCK_VERSION simultaneously
 
     @Getter
@@ -77,7 +78,7 @@ public class ChainConstant {
     public static final int SINGLE_REPEAT = 1;
     public static final int BLOCK_FILLED_SLOTS_NUMBER = 128;
     public static final int MAX_FROZEN_NUMBER = 1;
-    public static final int BLOCK_VERSION = 34;
+    public static final int BLOCK_VERSION = 35;
     public static final long FROZEN_PERIOD = 86_400_000L;
     public static final long DELEGATE_PERIOD = 3 * 86_400_000L;
     public static final long TRX_PRECISION = 1000_000L;

common/src/main/java/org/tron/core/vm/config/VMConfig.java

@@ -61,6 +61,12 @@ public class VMConfig {
 
   private static boolean ALLOW_TVM_SELFDESTRUCT_RESTRICTION = false;
 
+  private static boolean ALLOW_OPTIMIZED_BN128 = false;
+
+  private static int BN128_CLIENT_PORT = 9001;
+
+  private static int BN128_SOCKET_TIMEOUT = 30;
+
   private VMConfig() {
   }
 
@@ -172,6 +178,18 @@ public static void initAllowTvmSelfdestructRestriction(long allow) {
     ALLOW_TVM_SELFDESTRUCT_RESTRICTION = allow == 1;
   }
 
+  public static void initAllowOptimizedBN128(long allow) {
+    ALLOW_OPTIMIZED_BN128 = allow == 1;
+  }
+
+  public static void initBN128Port(int port) {
+    BN128_CLIENT_PORT = port;
+  }
+
+  public static void initBN128SocketTimeout(int timeout) {
+    BN128_SOCKET_TIMEOUT = timeout;
+  }
+
   public static boolean getEnergyLimitHardFork() {
     return CommonParameter.ENERGY_LIMIT_HARD_FORK;
   }
@@ -271,4 +289,16 @@ public static boolean allowTvmBlob() {
   public static boolean allowTvmSelfdestructRestriction() {
     return ALLOW_TVM_SELFDESTRUCT_RESTRICTION;
   }
+
+  public static boolean allowOptimizedBn128() {
+    return ALLOW_OPTIMIZED_BN128;
+  }
+
+  public static int getBN128ClientPort() {
+    return BN128_CLIENT_PORT;
+  }
+
+  public static int getBN128SocketTimeout() {
+    return BN128_SOCKET_TIMEOUT;
+  }
 }

crypto/build.gradle

@@ -12,6 +12,8 @@ repositories {
 
 dependencies {
     api project(":common")
+    api 'net.java.dev.jna:jna:5.12.1'
+    api 'com.github.federico2014.besu-native:gnark:1.3.11'
 }
 
 jacocoTestReport {

crypto/src/main/java/org/tron/common/crypto/bn128/BN128Executor.java

@@ -0,0 +1,92 @@
+package org.tron.common.crypto.bn128;
+
+import com.sun.jna.ptr.IntByReference;
+import java.util.Arrays;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.tuple.Pair;
+import org.hyperledger.besu.nativelib.gnark.LibGnarkEIP196;
+
+@Slf4j(topic = "crypto")
+public class BN128Executor {
+
+  public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
+
+  private static final int PAIR_SIZE = 192;
+
+  // Limit to 100 pairs (19,200 bytes) in optimized mode to prevent timeout attacks
+  private static final int MAX_PAIR_SIZE_LIMIT = 192 * 100;
+
+  public static Pair<Boolean, byte[]> add(byte[] data) {
+    if (data == null) {
+      data = EMPTY_BYTE_ARRAY;
+    }
+
+    byte[] input = data.length > 128
+        ? Arrays.copyOfRange(data, 0, 128) : data;
+    Pair<Boolean, byte[]> result = executeEIP196Operation(
+        LibGnarkEIP196.EIP196_ADD_OPERATION_RAW_VALUE, input);
+    return result;
+  }
+
+  public static Pair<Boolean, byte[]> mul(byte[] data) {
+    if (data == null) {
+      data = EMPTY_BYTE_ARRAY;
+    }
+
+    byte[] input = data.length > 96
+        ? Arrays.copyOfRange(data, 0, 96) : data;
+    Pair<Boolean, byte[]> result = executeEIP196Operation(
+        LibGnarkEIP196.EIP196_MUL_OPERATION_RAW_VALUE, input);
+    return result;
+  }
+
+  public static Pair<Boolean, byte[]> pairing(byte[] data) {
+    if (data == null) {
+      data = EMPTY_BYTE_ARRAY;
+    }
+
+    if (data.length > MAX_PAIR_SIZE_LIMIT
+        || data.length % PAIR_SIZE > 0) {
+      return Pair.of(false, EMPTY_BYTE_ARRAY);
+    }
+    Pair<Boolean, byte[]> result = executeEIP196Operation(
+        LibGnarkEIP196.EIP196_PAIR_OPERATION_RAW_VALUE, data);
+    return result;
+
+  }
+
+
+  private static Pair<Boolean, byte[]> executeEIP196Operation(
+      byte operation, byte[] data) {
+    if (!LibGnarkEIP196.ENABLED) {
+      logger.warn("Native BN128 library not available, "
+          + "cannot execute optimized path");
+      return null;
+    }
+
+    final byte[] output =
+        new byte[LibGnarkEIP196.EIP196_PREALLOCATE_FOR_RESULT_BYTES];
+    final IntByReference outputLength = new IntByReference();
+    final byte[] error =
+        new byte[LibGnarkEIP196.EIP196_PREALLOCATE_FOR_ERROR_BYTES];
+    final IntByReference errorLength = new IntByReference();
+
+    int ret = LibGnarkEIP196.eip196_perform_operation(
+        operation, data, data.length,
+        output, outputLength, error, errorLength);
+
+    if (ret == 0) {
+      return Pair.of(true,
+          subArray(output, 0, outputLength.getValue()));
+    } else {
+      return Pair.of(false, EMPTY_BYTE_ARRAY);
+    }
+  }
+
+  public static byte[] subArray(byte[] input, int start, int end) {
+    byte[] result = new byte[end - start];
+    System.arraycopy(input, start, result, 0, end - start);
+    return result;
+  }
+
+}