MACRO NEPAL
Quorum Private Transactions in Java
awiskar acharya
November 16, 2025
7:18 am

Overview

Quorum is an enterprise-focused Ethereum client that supports private transactions through privacy managers like Tessera. Private transactions allow specific participants to see transaction details while keeping them hidden from others on the network.

Key Concepts

Private Transaction Flow

  1. Transaction Creation: Encrypt payload for specific participants
  2. Privacy Manager: Handles encryption and key management (Tessera)
  3. Blockchain: Stores transaction hash, encrypted payload off-chain
  4. Participant Access: Only authorized nodes can decrypt and view details

Dependencies

<dependencies>
<!-- Web3j Quorum -->
<dependency>
<groupId>org.web3j</groupId>
<artifactId>quorum</artifactId>
<version>1.7.0</version>
</dependency>
<!-- Tessera client -->
<dependency>
<groupId>com.jpmorgan.quorum</groupId>
<artifactId>tessera-client</artifactId>
<version>1.0.0</version>
</dependency>
<!-- Ethereum core -->
<dependency>
<groupId>org.web3j</groupId>
<artifactId>core</artifactId>
<version>4.9.7</version>
</dependency>
<!-- JSON processing -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.15.2</version>
</dependency>
</dependencies>

Core Implementation

1. Quorum Service Configuration

@Component
public class QuorumConfig {
@Value("${quorum.rpc.url}")
private String rpcUrl;
@Value("${quorum.private.key}")
private String privateKey;
@Value("${tessera.url}")
private String tesseraUrl;
@Bean
public Quorum quorumClient() throws IOException {
return Quorum.build(new HttpService(rpcUrl));
}
@Bean
public Credentials credentials() {
return Credentials.create(privateKey);
}
@Bean
public TesseraClient tesseraClient() {
return new TesseraClient(tesseraUrl);
}
}

2. Private Transaction Manager

@Service
public class PrivateTransactionService {
private final Quorum quorum;
private final Credentials credentials;
private final TesseraClient tesseraClient;
public PrivateTransactionService(Quorum quorum, Credentials credentials, 
TesseraClient tesseraClient) {
this.quorum = quorum;
this.credentials = credentials;
this.tesseraClient = tesseraClient;
}
// Send private transaction to specific participants
public String sendPrivateTransaction(
String to, 
String data, 
List<String> privateFor, 
BigInteger value) throws Exception {
// Get transaction count for nonce
BigInteger nonce = quorum.ethGetTransactionCount(
credentials.getAddress(), 
DefaultBlockParameterName.LATEST
).send().getTransactionCount();
// Create raw private transaction
RawPrivateTransaction rawTx = RawPrivateTransaction.createTransaction(
nonce,
BigInteger.valueOf(0), // gasPrice
BigInteger.valueOf(3000000), // gasLimit
to,
value,
data,
privateFor
);
// Sign the transaction
byte[] signedTx = PrivateTransactionEncoder.signMessage(rawTx, credentials);
// Send to Quorum
EthSendTransaction response = quorum.ethSendRawPrivateTransaction(
Numeric.toHexString(signedTx)
).send();
if (response.hasError()) {
throw new RuntimeException("Transaction failed: " + response.getError().getMessage());
}
return response.getTransactionHash();
}
// Send private transaction with contract deployment
public String deployPrivateContract(
String bytecode, 
List<String> privateFor) throws Exception {
BigInteger nonce = quorum.ethGetTransactionCount(
credentials.getAddress(), 
DefaultBlockParameterName.LATEST
).send().getTransactionCount();
RawPrivateTransaction rawTx = RawPrivateTransaction.createContractTransaction(
nonce,
BigInteger.valueOf(0),
BigInteger.valueOf(4700000),
BigInteger.ZERO,
bytecode,
privateFor
);
byte[] signedTx = PrivateTransactionEncoder.signMessage(rawTx, credentials);
EthSendTransaction response = quorum.ethSendRawPrivateTransaction(
Numeric.toHexString(signedTx)
).send();
return response.getTransactionHash();
}
}

3. Enhanced Private Transaction with Payload Management

@Service
public class EnhancedPrivateTransactionService {
private final Quorum quorum;
private final TesseraClient tesseraClient;
public EnhancedPrivateTransactionService(Quorum quorum, TesseraClient tesseraClient) {
this.quorum = quorum;
this.tesseraClient = tesseraClient;
}
// Send private transaction with encrypted payload
public PrivateTransactionResult sendPrivateTransactionWithPayload(
PrivateTransactionRequest request) throws Exception {
// Encrypt payload for participants
EncryptedPayload encryptedPayload = encryptPayload(
request.getPayload(), 
request.getPrivateFor()
);
// Store encrypted payload in Tessera
String payloadId = tesseraClient.storePayload(encryptedPayload);
// Create transaction with payload reference
String transactionData = buildTransactionData(payloadId, request.getFunctionCall());
RawPrivateTransaction rawTx = RawPrivateTransaction.createTransaction(
request.getNonce(),
request.getGasPrice(),
request.getGasLimit(),
request.getTo(),
request.getValue(),
transactionData,
request.getPrivateFor()
);
byte[] signedTx = PrivateTransactionEncoder.signMessage(rawTx, request.getCredentials());
EthSendTransaction response = quorum.ethSendRawPrivateTransaction(
Numeric.toHexString(signedTx)
).send();
return new PrivateTransactionResult(
response.getTransactionHash(),
payloadId,
request.getPrivateFor()
);
}
private EncryptedPayload encryptPayload(String payload, List<String> participants) {
// Generate symmetric key for payload encryption
String symmetricKey = generateSymmetricKey();
// Encrypt payload with symmetric key
String encryptedPayload = encryptWithSymmetricKey(payload, symmetricKey);
// Encrypt symmetric key for each participant
Map<String, String> participantKeys = new HashMap<>();
for (String participant : participants) {
String encryptedKey = encryptKeyForParticipant(symmetricKey, participant);
participantKeys.put(participant, encryptedKey);
}
return new EncryptedPayload(encryptedPayload, participantKeys);
}
private String buildTransactionData(String payloadId, String functionCall) {
JSONObject data = new JSONObject();
data.put("payloadId", payloadId);
data.put("function", functionCall);
data.put("timestamp", Instant.now().toString());
return data.toString();
}
}

Smart Contract Integration

1. Private Contract Wrapper

public class PrivateContractWrapper {
private final Quorum quorum;
private final String contractAddress;
private final List<String> privateFor;
public PrivateContractWrapper(Quorum quorum, String contractAddress, List<String> privateFor) {
this.quorum = quorum;
this.contractAddress = contractAddress;
this.privateFor = privateFor;
}
// Call private contract function
public String callPrivateFunction(
String functionSignature, 
List<Type> parameters, 
Credentials credentials) throws Exception {
String encodedFunction = FunctionEncoder.encode(
new Function(functionSignature, parameters, Collections.emptyList())
);
BigInteger nonce = quorum.ethGetTransactionCount(
credentials.getAddress(), 
DefaultBlockParameterName.LATEST
).send().getTransactionCount();
RawPrivateTransaction rawTx = RawPrivateTransaction.createTransaction(
nonce,
BigInteger.ZERO,
BigInteger.valueOf(1000000),
contractAddress,
BigInteger.ZERO,
encodedFunction,
privateFor
);
byte[] signedTx = PrivateTransactionEncoder.signMessage(rawTx, credentials);
EthSendTransaction response = quorum.ethSendRawPrivateTransaction(
Numeric.toHexString(signedTx)
).send();
return response.getTransactionHash();
}
// Read private state (uses eth_call)
public List<Type> readPrivateState(
String functionSignature,
List<Type> parameters,
String fromAddress) throws Exception {
String encodedFunction = FunctionEncoder.encode(
new Function(functionSignature, parameters, Collections.emptyList())
);
org.web3j.protocol.core.methods.request.Transaction transaction = 
org.web3j.protocol.core.methods.request.Transaction.createEthCallTransaction(
fromAddress, contractAddress, encodedFunction);
// For private transactions, we need to use eth_storageRoot or similar
// This is a simplified example
EthCall response = quorum.ethCall(transaction, DefaultBlockParameterName.LATEST).send();
return FunctionReturnDecoder.decode(response.getValue(), 
new Function(functionSignature, parameters, Collections.emptyList()).getOutputParameters());
}
}

2. Private State Management

@Service
public class PrivateStateService {
private final Quorum quorum;
private final TesseraClient tesseraClient;
public PrivateStateService(Quorum quorum, TesseraClient tesseraClient) {
this.quorum = quorum;
this.tesseraClient = tesseraClient;
}
// Get private transaction receipt
public PrivateTransactionReceipt getPrivateTransactionReceipt(String transactionHash) 
throws Exception {
EthGetTransactionReceipt receiptResponse = 
quorum.ethGetTransactionReceipt(transactionHash).send();
if (!receiptResponse.getTransactionReceipt().isPresent()) {
throw new RuntimeException("Transaction receipt not found");
}
TransactionReceipt receipt = receiptResponse.getTransactionReceipt().get();
// For private transactions, we might need to fetch additional data from Tessera
String privatePayload = fetchPrivatePayload(transactionHash);
return new PrivateTransactionReceipt(receipt, privatePayload);
}
// Check if transaction is private
public boolean isPrivateTransaction(String transactionHash) throws Exception {
EthGetTransactionResponse response = quorum.ethGetTransactionByHash(transactionHash).send();
if (!response.getTransaction().isPresent()) {
return false;
}
Transaction tx = response.getTransaction().get();
// In Quorum, private transactions have specific markers
return tx.getInput().startsWith("0xee") || 
(tx.getV() != null && tx.getV().equals(BigInteger.valueOf(37)));
}
// Get participants for private transaction
public List<String> getTransactionParticipants(String transactionHash) throws Exception {
// This would typically involve querying Tessera or the privacy manager
PrivateTransactionPayload payload = tesseraClient.getPayload(transactionHash);
return payload.getParticipants();
}
}

Advanced Features

1. Multi-Party Private Transactions

@Service
public class MultiPartyPrivateService {
private final Map<String, Quorum> quorumNodes;
private final TesseraClient tesseraClient;
public MultiPartyPrivateService(TesseraClient tesseraClient) {
this.quorumNodes = new HashMap<>();
this.tesseraClient = tesseraClient;
}
public void addNode(String nodeId, String rpcUrl) {
quorumNodes.put(nodeId, Quorum.build(new HttpService(rpcUrl)));
}
// Send transaction to multiple Quorum nodes with different privacy groups
public Map<String, String> sendToMultipleParties(
PrivateTransactionRequest request,
Map<String, List<String>> nodePrivacyGroups) throws Exception {
Map<String, String> results = new HashMap<>();
for (Map.Entry<String, List<String>> entry : nodePrivacyGroups.entrySet()) {
String nodeId = entry.getKey();
List<String> privacyGroup = entry.getValue();
Quorum node = quorumNodes.get(nodeId);
if (node != null) {
String txHash = sendToNode(node, request, privacyGroup);
results.put(nodeId, txHash);
}
}
return results;
}
private String sendToNode(Quorum node, PrivateTransactionRequest request, 
List<String> privacyGroup) throws Exception {
RawPrivateTransaction rawTx = RawPrivateTransaction.createTransaction(
request.getNonce(),
request.getGasPrice(),
request.getGasLimit(),
request.getTo(),
request.getValue(),
request.getData(),
privacyGroup
);
byte[] signedTx = PrivateTransactionEncoder.signMessage(rawTx, request.getCredentials());
EthSendTransaction response = node.ethSendRawPrivateTransaction(
Numeric.toHexString(signedTx)
).send();
return response.getTransactionHash();
}
}

2. Privacy Group Management

@Service
public class PrivacyGroupService {
private final TesseraClient tesseraClient;
private final Map<String, PrivacyGroup> privacyGroups;
public PrivacyGroupService(TesseraClient tesseraClient) {
this.tesseraClient = tesseraClient;
this.privacyGroups = new HashMap<>();
}
// Create new privacy group
public String createPrivacyGroup(String name, List<String> participants, 
String description) throws Exception {
PrivacyGroup group = new PrivacyGroup(name, participants, description);
String groupId = generateGroupId(participants);
// Register with Tessera
tesseraClient.createPrivacyGroup(groupId, group);
privacyGroups.put(groupId, group);
return groupId;
}
// Add participant to privacy group
public void addToPrivacyGroup(String groupId, String participant) throws Exception {
PrivacyGroup group = privacyGroups.get(groupId);
if (group != null && !group.getParticipants().contains(participant)) {
group.getParticipants().add(participant);
tesseraClient.updatePrivacyGroup(groupId, group);
}
}
// Remove participant from privacy group
public void removeFromPrivacyGroup(String groupId, String participant) throws Exception {
PrivacyGroup group = privacyGroups.get(groupId);
if (group != null) {
group.getParticipants().remove(participant);
tesseraClient.updatePrivacyGroup(groupId, group);
}
}
// Find transactions for privacy group
public List<String> getGroupTransactions(String groupId) throws Exception {
return tesseraClient.getTransactionsForGroup(groupId);
}
private String generateGroupId(List<String> participants) {
// Sort participants for consistent ID generation
List<String> sorted = new ArrayList<>(participants);
Collections.sort(sorted);
String concatenated = String.join("", sorted);
return Hashing.sha256().hashString(concatenated, StandardCharsets.UTF_8).toString();
}
}

Security and Monitoring

1. Transaction Security Layer

@Service
public class TransactionSecurityService {
private final Quorum quorum;
private final TesseraClient tesseraClient;
public TransactionSecurityService(Quorum quorum, TesseraClient tesseraClient) {
this.quorum = quorum;
this.tesseraClient = tesseraClient;
}
// Validate private transaction before sending
public ValidationResult validatePrivateTransaction(PrivateTransactionRequest request) {
ValidationResult result = new ValidationResult();
// Check participant validity
for (String participant : request.getPrivateFor()) {
if (!isValidParticipant(participant)) {
result.addError("Invalid participant: " + participant);
}
}
// Check gas limits
if (request.getGasLimit().compareTo(BigInteger.valueOf(10000000)) > 0) {
result.addError("Gas limit too high");
}
// Check data size for private transactions
if (request.getData().length() > 100000) { // arbitrary limit
result.addError("Transaction data too large for private transaction");
}
return result;
}
// Monitor private transaction lifecycle
public void monitorPrivateTransaction(String transactionHash) {
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
scheduler.scheduleAtFixedRate(() -> {
try {
TransactionReceipt receipt = getTransactionReceipt(transactionHash);
if (receipt != null) {
handleTransactionMined(receipt);
scheduler.shutdown();
}
} catch (Exception e) {
log.error("Error monitoring transaction: " + transactionHash, e);
}
}, 0, 5, TimeUnit.SECONDS); // Check every 5 seconds
}
private boolean isValidParticipant(String participant) {
// Validate participant format and existence
return participant.matches("^[a-fA-F0-9]{40}$"); // Basic Ethereum address format
}
}

2. Audit and Compliance

@Service
public class PrivateTransactionAuditService {
private final Quorum quorum;
private final AuditRepository auditRepository;
public PrivateTransactionAuditService(Quorum quorum, AuditRepository auditRepository) {
this.quorum = quorum;
this.auditRepository = auditRepository;
}
// Log private transaction for compliance
public void auditPrivateTransaction(PrivateTransactionRequest request, 
String transactionHash, 
String userId) {
AuditRecord record = new AuditRecord(
UUID.randomUUID().toString(),
userId,
request.getTo(),
transactionHash,
Instant.now(),
request.getPrivateFor(),
"PRIVATE_TX_SENT"
);
auditRepository.save(record);
}
// Generate compliance report
public ComplianceReport generateComplianceReport(String timeframe, String organization) {
List<AuditRecord> records = auditRepository.findByTimeframeAndOrganization(
timeframe, organization);
ComplianceReport report = new ComplianceReport();
report.setTotalTransactions(records.size());
Map<String, Integer> participantCount = new HashMap<>();
for (AuditRecord record : records) {
for (String participant : record.getParticipants()) {
participantCount.merge(participant, 1, Integer::sum);
}
}
report.setParticipantDistribution(participantCount);
return report;
}
}

Configuration and Properties

application.yml

quorum:
rpc:
url: http://localhost:8545
private:
key: ${PRIVATE_KEY:0x...}
tessera:
url: http://localhost:9081
third-party-url: http://localhost:9081
privacy:
default-participants:
- "0xfe3b557e8fb62b89f4916b721be55ceb828dbd73"
- "0x627306090abab3a6e1400e9345bc60c78a8bef57"
security:
max-gas-limit: 10000000
max-data-size: 100000

Testing

@SpringBootTest
class PrivateTransactionTest {
@Autowired
private PrivateTransactionService privateTxService;
@Test
void testSendPrivateTransaction() throws Exception {
List<String> privateFor = Arrays.asList(
"0xfe3b557e8fb62b89f4916b721be55ceb828dbd73",
"0x627306090abab3a6e1400e9345bc60c78a8bef57"
);
String txHash = privateTxService.sendPrivateTransaction(
"0x...", // to address
"0x...", // data
privateFor,
BigInteger.ZERO
);
assertNotNull(txHash);
assertTrue(txHash.startsWith("0x"));
}
@Test
void testPrivateContractDeployment() throws Exception {
String bytecode = "0x606060..."; // Contract bytecode
List<String> privateFor = Arrays.asList("0x...");
String txHash = privateTxService.deployPrivateContract(bytecode, privateFor);
assertNotNull(txHash);
}
}

Best Practices

  1. Key Management: Use secure key storage (HSM, cloud KMS)
  2. Participant Validation: Validate all participants before sending
  3. Gas Optimization: Set appropriate gas limits for private transactions
  4. Error Handling: Implement comprehensive error handling for privacy manager communication
  5. Monitoring: Monitor private transaction lifecycle and privacy manager health
  6. Backup: Regularly backup Tessera data and configuration
  7. Compliance: Maintain audit trails for regulatory requirements

This implementation provides a comprehensive foundation for working with Quorum private transactions in Java, covering transaction creation, privacy groups, security, and compliance aspects.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper