track-privacy-head

Signed-off-by: Ivaylo Kirilov <iikirilov@gmail.com>

besu/src/test/java/org/hyperledger/besu/PrivacyReorgTest.java

@@ -45,6 +45,7 @@
 import org.hyperledger.besu.ethereum.privacy.PrivateTransaction;
 import org.hyperledger.besu.ethereum.privacy.Restriction;
 import org.hyperledger.besu.ethereum.privacy.storage.PrivacyStorageProvider;
+import org.hyperledger.besu.ethereum.privacy.storage.PrivateGroupIdToLatestBlockwithTransactionMap;
 import org.hyperledger.besu.ethereum.privacy.storage.PrivateStateStorage;
 import org.hyperledger.besu.ethereum.privacy.storage.keyvalue.PrivacyKeyValueStorageProviderBuilder;
 import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
@@ -168,9 +169,6 @@ public void privacyGroupHeadIsTracked() {
     final ProtocolContext<?> protocolContext = besuController.getProtocolContext();
     final DefaultBlockchain blockchain = (DefaultBlockchain) protocolContext.getBlockchain();
     final PrivateStateStorage privateStateStorage = privacyParameters.getPrivateStateStorage();
-    final BytesValue privacyGroupId =
-        BytesValue.fromHexString(
-            "0xfd3d679c20d01667629ab31c47efd69b1aca3ae3eafe5096a7cdb7948310baa6");
 
     final Block firstBlock =
         gen.block(
@@ -190,21 +188,32 @@ public void privacyGroupHeadIsTracked() {
 
     appendBlock(besuController, blockchain, protocolContext, firstBlock);
 
+    final PrivateGroupIdToLatestBlockwithTransactionMap expected =
+        new PrivateGroupIdToLatestBlockwithTransactionMap(
+            Collections.singletonMap(
+                Bytes32.fromHexString(
+                    "0xf250d523ae9164722b06ca25cfa2a7f3c45df96b09e215236f886c876f715bfa"),
+                firstBlock.getHash()));
+
     assertThat(
-            privateStateStorage.getPrivacyGroupHead(
-                blockchain.getGenesisBlock().getHash(), Bytes32.wrap(privacyGroupId)))
+            privateStateStorage.getPrivacyGroupToLatestBlockWithTransactionMap(
+                blockchain.getGenesisBlock().getHash()))
         .isEmpty();
     assertThat(
-            privateStateStorage.getPrivacyGroupHead(
-                firstBlock.getHash(), Bytes32.wrap(privacyGroupId)))
-        .contains(firstBlock.getHash());
+            privateStateStorage.getPrivacyGroupToLatestBlockWithTransactionMap(
+                firstBlock.getHash()))
+        .isNotEmpty();
+    assertThat(
+            privateStateStorage.getPrivacyGroupToLatestBlockWithTransactionMap(
+                firstBlock.getHash()))
+        .contains(expected);
 
     final Block secondBlock =
         gen.block(
             new BlockDataGenerator.BlockOptions()
                 .setBlockNumber(2)
                 .setParentHash(firstBlock.getHeader().getHash())
-                .addTransaction(generateMarker(getEnclaveKey(enclave.clientUrl())))
+                .hasTransactions(false)
                 .hasOmmers(false)
                 .setReceiptsRoot(
                     Hash.fromHexString(
@@ -215,10 +224,17 @@ public void privacyGroupHeadIsTracked() {
                     Hash.fromHexString(
                         "0x35c315ee7d272e5b612d454ee87c948657310ab33208b57122f8d0525e91f35e")));
 
+    appendBlock(besuController, blockchain, protocolContext, secondBlock);
+
+    assertThat(
+            privateStateStorage.getPrivacyGroupToLatestBlockWithTransactionMap(
+                secondBlock.getHash()))
+        .isNotEmpty();
+
     assertThat(
-            privateStateStorage.getPrivacyGroupHead(
-                secondBlock.getHash(), Bytes32.wrap(privacyGroupId)))
-        .contains(firstBlock.getHash());
+            privateStateStorage.getPrivacyGroupToLatestBlockWithTransactionMap(
+                firstBlock.getHash()))
+        .contains(expected);
   }
 
   @Test

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/MainnetBlockValidator.java

@@ -16,19 +16,33 @@
 
 import static org.apache.logging.log4j.LogManager.getLogger;
 
+import org.hyperledger.besu.enclave.Enclave;
+import org.hyperledger.besu.enclave.types.ReceiveRequest;
+import org.hyperledger.besu.enclave.types.ReceiveResponse;
 import org.hyperledger.besu.ethereum.chain.MutableBlockchain;
+import org.hyperledger.besu.ethereum.core.Address;
 import org.hyperledger.besu.ethereum.core.Block;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
+import org.hyperledger.besu.ethereum.core.Hash;
 import org.hyperledger.besu.ethereum.core.MutableWorldState;
+import org.hyperledger.besu.ethereum.core.PrivacyParameters;
 import org.hyperledger.besu.ethereum.core.TransactionReceipt;
 import org.hyperledger.besu.ethereum.mainnet.BlockBodyValidator;
 import org.hyperledger.besu.ethereum.mainnet.BlockHeaderValidator;
 import org.hyperledger.besu.ethereum.mainnet.BlockProcessor;
 import org.hyperledger.besu.ethereum.mainnet.HeaderValidationMode;
-
+import org.hyperledger.besu.ethereum.privacy.storage.PrivateGroupIdToLatestBlockwithTransactionMap;
+import org.hyperledger.besu.ethereum.privacy.storage.PrivateStateStorage;
+import org.hyperledger.besu.util.bytes.Bytes32;
+import org.hyperledger.besu.util.bytes.BytesValue;
+import org.hyperledger.besu.util.bytes.BytesValues;
+
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Optional;
 
+import com.google.common.collect.Maps;
 import org.apache.logging.log4j.Logger;
 
 public class MainnetBlockValidator<C> implements BlockValidator<C> {
@@ -40,14 +54,30 @@ public class MainnetBlockValidator<C> implements BlockValidator<C> {
   private final BlockBodyValidator<C> blockBodyValidator;
 
   private final BlockProcessor blockProcessor;
+  private PrivacyParameters privacyParameters;
+
+  private PrivateStateStorage privateStateStorage;
+  private Address address;
+  private Enclave enclave;
 
   public MainnetBlockValidator(
       final BlockHeaderValidator<C> blockHeaderValidator,
       final BlockBodyValidator<C> blockBodyValidator,
-      final BlockProcessor blockProcessor) {
+      final BlockProcessor blockProcessor,
+      final PrivacyParameters privacyParameters) {
     this.blockHeaderValidator = blockHeaderValidator;
     this.blockBodyValidator = blockBodyValidator;
     this.blockProcessor = blockProcessor;
+    this.privacyParameters = privacyParameters;
+    setUpForPrivacy(privacyParameters);
+  }
+
+  private void setUpForPrivacy(final PrivacyParameters privacyParameters) {
+    if (privacyParameters.isEnabled()) {
+      privateStateStorage = privacyParameters.getPrivateStateStorage();
+      address = Address.privacyPrecompiled(privacyParameters.getPrivacyAddress());
+      enclave = new Enclave(privacyParameters.getEnclaveUri());
+    }
   }
 
   @Override
@@ -90,9 +120,33 @@ public Optional<BlockProcessingOutputs> validateAndProcessBlock(
       return Optional.empty();
     }
 
-    // get all groups
-    // for each group check if there is a PMT for that group in this block and update the head
-    // for all other groups copy the head from the parent of this block being processed
+    if (privacyParameters.isEnabled()) {
+      // get all groups
+      final HashMap<Bytes32, Hash> privacyGroupToLatestBlockWithTransactionMap =
+          Maps.newHashMap(
+              privateStateStorage
+                  .getPrivacyGroupToLatestBlockWithTransactionMap(block.getHeader().getParentHash())
+                  .map(PrivateGroupIdToLatestBlockwithTransactionMap::getMap)
+                  .orElse(Collections.emptyMap()));
+      block.getBody().getTransactions().stream()
+          .filter(t -> t.getTo().isPresent() && t.getTo().get().equals(address))
+          .forEach(
+              t -> {
+                final String key = BytesValues.asBase64String(t.getData().get());
+                final ReceiveResponse receiveResponse = enclave.receive(new ReceiveRequest(key));
+                final BytesValue privacyGroupId =
+                    BytesValues.fromBase64(receiveResponse.getPrivacyGroupId());
+                privacyGroupToLatestBlockWithTransactionMap.put(
+                    Bytes32.wrap(privacyGroupId), block.getHash());
+              });
+      privateStateStorage
+          .updater()
+          .putPrivacyGroupToLatestBlockWithTransactionMap(
+              block.getHash(),
+              new PrivateGroupIdToLatestBlockwithTransactionMap(
+                  privacyGroupToLatestBlockWithTransactionMap))
+          .commit();
+    }
 
     final List<TransactionReceipt> receipts = result.getReceipts();
     if (!blockBodyValidator.validateBody(

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/ProtocolSpecBuilder.java

@@ -314,7 +314,8 @@ public ProtocolSpec<T> build(final ProtocolSchedule<T> protocolSchedule) {
             miningBeneficiaryCalculator,
             skipZeroBlockRewards);
     final BlockValidator<T> blockValidator =
-        blockValidatorBuilder.apply(blockHeaderValidator, blockBodyValidator, blockProcessor);
+        blockValidatorBuilder.apply(
+            blockHeaderValidator, blockBodyValidator, blockProcessor, privacyParameters);
     final BlockImporter<T> blockImporter = blockImporterBuilder.apply(blockValidator);
     return new ProtocolSpec<>(
         name,
@@ -372,7 +373,8 @@ public interface BlockValidatorBuilder<T> {
     BlockValidator<T> apply(
         BlockHeaderValidator<T> blockHeaderValidator,
         BlockBodyValidator<T> blockBodyValidator,
-        BlockProcessor blockProcessor);
+        BlockProcessor blockProcessor,
+        PrivacyParameters privacyParameters);
   }
 
   public interface BlockImporterBuilder<T> {

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/privacy/storage/PrivateGroupIdBlockHashMapEntry.java

@@ -19,39 +19,54 @@
 import org.hyperledger.besu.ethereum.rlp.RLPOutput;
 import org.hyperledger.besu.util.bytes.Bytes32;
 
+import java.util.Objects;
+
 public class PrivateGroupIdBlockHashMapEntry {
-    private final Bytes32 privacyGroup;
-    private final Hash blockHash;
+  private final Bytes32 privacyGroup;
+  private final Hash blockHash;
+
+  public PrivateGroupIdBlockHashMapEntry(final Bytes32 privacyGroup, final Hash blockHash) {
+    this.privacyGroup = privacyGroup;
+    this.blockHash = blockHash;
+  }
+
+  public Hash getBlockHash() {
+    return blockHash;
+  }
 
-    public PrivateGroupIdBlockHashMapEntry(final Bytes32 privacyGroup, final Hash blockHash) {
-        this.privacyGroup = privacyGroup;
-        this.blockHash = blockHash;
-    }
+  public Bytes32 getPrivacyGroup() {
+    return privacyGroup;
+  }
 
-    public Hash getBlockHash() {
-        return blockHash;
-    }
+  public void writeTo(final RLPOutput out) {
+    out.startList();
 
-    public Bytes32 getPrivacyGroup() {
-        return privacyGroup;
-    }
+    out.writeBytesValue(privacyGroup);
+    out.writeBytesValue(blockHash);
 
-    public void writeTo(final RLPOutput out) {
-        out.startList();
+    out.endList();
+  }
 
-        out.writeBytesValue(privacyGroup);
-        out.writeBytesValue(blockHash);
+  public static PrivateGroupIdBlockHashMapEntry readFrom(final RLPInput input) {
+    input.enterList();
 
-        out.endList();
-    }
+    final PrivateGroupIdBlockHashMapEntry privateTransactionMetadata =
+        new PrivateGroupIdBlockHashMapEntry(input.readBytes32(), Hash.wrap(input.readBytes32()));
 
-    public static PrivateGroupIdBlockHashMapEntry readFrom(final RLPInput input) {
-        input.enterList();
+    input.leaveList();
+    return privateTransactionMetadata;
+  }
 
-        final PrivateGroupIdBlockHashMapEntry privateTransactionMetadata =
-                new PrivateGroupIdBlockHashMapEntry(input.readBytes32(), Hash.wrap(input.readBytes32()));
+  @Override
+  public boolean equals(final Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    final PrivateGroupIdBlockHashMapEntry that = (PrivateGroupIdBlockHashMapEntry) o;
+    return privacyGroup.equals(that.privacyGroup) && blockHash.equals(that.blockHash);
+  }
 
-        input.leaveList();
-        return privateTransactionMetadata;
-    }
+  @Override
+  public int hashCode() {
+    return Objects.hash(privacyGroup, blockHash);
+  }
 }

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/privacy/storage/PrivateGroupIdToLatestBlockwithTransactionMap.java

@@ -22,37 +22,58 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 
 public class PrivateGroupIdToLatestBlockwithTransactionMap {
-    private final Map<Bytes32, Hash> map;
+  private final Map<Bytes32, Hash> map;
 
-    public final static PrivateGroupIdToLatestBlockwithTransactionMap EMPTY = new PrivateGroupIdToLatestBlockwithTransactionMap(new HashMap<>());
+  public static final PrivateGroupIdToLatestBlockwithTransactionMap EMPTY =
+      new PrivateGroupIdToLatestBlockwithTransactionMap(new HashMap<>());
 
-    public PrivateGroupIdToLatestBlockwithTransactionMap(final Map<Bytes32, Hash> map) {
-        this.map= map;
-    }
+  public PrivateGroupIdToLatestBlockwithTransactionMap(final Map<Bytes32, Hash> map) {
+    this.map = map;
+  }
 
-    public Map<Bytes32, Hash> getMap() {
-        return map;
-    }
+  public Map<Bytes32, Hash> getMap() {
+    return map;
+  }
 
-    public void writeTo(final RLPOutput out) {
-        out.startList();
+  public void writeTo(final RLPOutput out) {
+    out.startList();
 
-        map.entrySet().stream().forEach(e -> {
-            out.writeBytesValue(e.getKey());
-            out.writeBytesValue(e.getValue());
-        });
+    map.entrySet()
+        .forEach(
+            e -> {
+              out.startList();
+              out.writeBytesValue(e.getKey());
+              out.writeBytesValue(e.getValue());
+              out.endList();
+            });
 
-        out.endList();
-    }
+    out.endList();
+  }
 
-    public static PrivateGroupIdToLatestBlockwithTransactionMap readFrom(final RLPInput input) {
-        final List<PrivateGroupIdBlockHashMapEntry> entries = input.readList(PrivateGroupIdBlockHashMapEntry::readFrom);
+  public static PrivateGroupIdToLatestBlockwithTransactionMap readFrom(final RLPInput input) {
+    final List<PrivateGroupIdBlockHashMapEntry> entries =
+        input.readList(PrivateGroupIdBlockHashMapEntry::readFrom);
 
-        final HashMap<Bytes32, Hash> map = new HashMap<>();
-        entries.stream().forEach(e -> map.put(e.getPrivacyGroup(), e.getBlockHash()));
+    final HashMap<Bytes32, Hash> map = new HashMap<>();
+    entries.stream().forEach(e -> map.put(e.getPrivacyGroup(), e.getBlockHash()));
 
-        return new PrivateGroupIdToLatestBlockwithTransactionMap(map);
-    }
+    return new PrivateGroupIdToLatestBlockwithTransactionMap(map);
+  }
+
+  @Override
+  public boolean equals(final Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    final PrivateGroupIdToLatestBlockwithTransactionMap that =
+        (PrivateGroupIdToLatestBlockwithTransactionMap) o;
+    return map.equals(that.map);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(map);
+  }
 }