getDelayedFuture(final Duration delay) {
+ return runAfterDelay(() -> SafeFuture.COMPLETE, delay);
+ }
+
+ /**
+ * Schedules the recurrent task which will be repeatedly executed with the specified delay.
+ *
+ * The returned instance can be used to cancel the task. Note that {@link Cancellable#cancel()}
+ * doesn't interrupt already running task.
+ *
+ *
Whenever the {@code runnable} throws exception it is notified to the {@code
+ * exceptionHandler} and the task recurring executions are not interrupted
+ */
+ default Cancellable runWithFixedDelay(
+ final ExceptionThrowingRunnable runnable,
+ final Duration delay,
+ final Consumer exceptionHandler) {
+ Preconditions.checkNotNull(exceptionHandler);
+
+ Cancellable cancellable = FutureUtil.createCancellable();
+ FutureUtil.runWithFixedDelay(this, runnable, cancellable, delay, exceptionHandler);
+ return cancellable;
+ }
+
+ /**
+ * Execute the future supplier until it completes normally up to some maximum number of retries.
+ *
+ * @param action The action to run
+ * @param retryDelay The time to wait before retrying
+ * @param maxRetries The maximum number of retries. A value of 0 means the action is run only once
+ * (no retries).
+ * @param The value returned by the action future
+ * @return A future that resolves with the first successful result, or else an error if the
+ * maximum retries are exhausted.
+ */
+ default SafeFuture runWithRetry(
+ final ExceptionThrowingFutureSupplier action,
+ final Duration retryDelay,
+ final int maxRetries) {
+
+ return SafeFuture.of(action)
+ .exceptionallyCompose(
+ err -> {
+ if (maxRetries > 0) {
+ // Retry after delay, decrementing the remaining available retries
+ final int remainingRetries = maxRetries - 1;
+ return runAfterDelay(
+ () -> runWithRetry(action, retryDelay, remainingRetries), retryDelay);
+ } else {
+ return SafeFuture.failedFuture(err);
+ }
+ });
+ }
+}
diff --git a/src/org/minima/system/network/base/Cancellable.java b/src/org/minima/system/network/base/Cancellable.java
new file mode 100644
index 000000000..9b65a8d7a
--- /dev/null
+++ b/src/org/minima/system/network/base/Cancellable.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+public interface Cancellable {
+
+ void cancel();
+
+ boolean isCancelled();
+}
diff --git a/src/org/minima/system/network/base/ConnectionManager.java b/src/org/minima/system/network/base/ConnectionManager.java
new file mode 100644
index 000000000..b412193c5
--- /dev/null
+++ b/src/org/minima/system/network/base/ConnectionManager.java
@@ -0,0 +1,236 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import static java.util.stream.Collectors.toList;
+
+import java.time.Duration;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Predicate;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.minima.system.network.base.metrics.Counter;
+import org.minima.system.network.base.metrics.LabelledMetric;
+import org.minima.system.network.base.metrics.MetricsSystem;
+import org.minima.system.network.base.metrics.TekuMetricCategory;
+import org.minima.system.network.base.peer.DisconnectReason;
+import org.minima.system.network.base.peer.DiscoveryPeer;
+import org.minima.system.network.base.peer.Peer;
+// // import org.hyperledger.besu.plugin.services.MetricsSystem;
+// // import org.hyperledger.besu.plugin.services.metrics.Counter;
+// // import org.hyperledger.besu.plugin.services.metrics.LabelledMetric;
+// import tech.pegasys.teku.infrastructure.async.AsyncRunner;
+// import tech.pegasys.teku.infrastructure.async.Cancellable;
+// import tech.pegasys.teku.infrastructure.async.SafeFuture;
+// import tech.pegasys.teku.infrastructure.metrics.TekuMetricCategory;
+// import tech.pegasys.teku.networking.p2p.connection.PeerPools.PeerPool;
+// import tech.pegasys.teku.networking.p2p.discovery.DiscoveryPeer;
+// import tech.pegasys.teku.networking.p2p.discovery.DiscoveryService;
+// import tech.pegasys.teku.networking.p2p.network.P2PNetwork;
+// import tech.pegasys.teku.networking.p2p.network.PeerAddress;
+// import tech.pegasys.teku.networking.p2p.peer.DisconnectReason;
+// import tech.pegasys.teku.networking.p2p.peer.Peer;
+// import tech.pegasys.teku.service.serviceutils.Service;
+import org.minima.system.network.base.peer.PeerAddress;
+import org.minima.system.network.base.peer.PeerPools;
+import org.minima.system.network.base.peer.PeerSelectionStrategy;
+import org.minima.system.network.base.peer.PeerPools.PeerPool;
+
+public class ConnectionManager extends Service {
+ private static final Logger LOG = LogManager.getLogger(ConnectionManager.class);
+ private static final Duration RECONNECT_TIMEOUT = Duration.ofSeconds(20);
+ private static final Duration DISCOVERY_INTERVAL = Duration.ofSeconds(30);
+ private final AsyncRunner asyncRunner;
+ private final P2PNetwork network;
+ private final Set staticPeers;
+ private final DiscoveryService discoveryService;
+ private final PeerSelectionStrategy peerSelectionStrategy;
+ private final Counter attemptedConnectionCounter;
+ private final Counter successfulConnectionCounter;
+ private final Counter failedConnectionCounter;
+ private final PeerPools peerPools = new PeerPools();
+ private final Collection> peerPredicates = new CopyOnWriteArrayList<>();
+
+ private volatile long peerConnectedSubscriptionId;
+ private volatile Cancellable periodicPeerSearch;
+
+ public ConnectionManager(
+ final MetricsSystem metricsSystem,
+ final DiscoveryService discoveryService,
+ final AsyncRunner asyncRunner,
+ final P2PNetwork network,
+ final PeerSelectionStrategy peerSelectionStrategy,
+ final List peerAddresses) {
+ this.asyncRunner = asyncRunner;
+ this.network = network;
+ this.staticPeers = new HashSet<>(peerAddresses);
+ this.discoveryService = discoveryService;
+ this.peerSelectionStrategy = peerSelectionStrategy;
+
+ final LabelledMetric connectionAttemptCounter =
+ metricsSystem.createLabelledCounter(
+ TekuMetricCategory.NETWORK,
+ "peer_connection_attempt_count",
+ "Total number of outbound connection attempts made",
+ "status");
+ attemptedConnectionCounter = connectionAttemptCounter.labels("attempted");
+ successfulConnectionCounter = connectionAttemptCounter.labels("successful");
+ failedConnectionCounter = connectionAttemptCounter.labels("failed");
+ }
+
+ @Override
+ protected SafeFuture doStart() {
+ LOG.trace("Starting discovery manager");
+ synchronized (this) {
+ staticPeers.forEach(this::createPersistentConnection);
+ }
+ periodicPeerSearch =
+ asyncRunner.runWithFixedDelay(
+ this::searchForPeers,
+ DISCOVERY_INTERVAL,
+ error -> LOG.error("Error while searching for peers", error));
+ connectToKnownPeers();
+ searchForPeers();
+ peerConnectedSubscriptionId = network.subscribeConnect(this::onPeerConnected);
+ return SafeFuture.COMPLETE;
+ }
+
+ private void connectToKnownPeers() {
+ peerSelectionStrategy
+ .selectPeersToConnect(
+ network,
+ peerPools,
+ () -> discoveryService.streamKnownPeers().filter(this::isPeerValid).collect(toList()))
+ .forEach(this::attemptConnection);
+ }
+
+ private void searchForPeers() {
+ if (!isRunning()) {
+ LOG.debug("Not running so not searching for peers");
+ return;
+ }
+ LOG.debug("Searching for peers");
+ discoveryService
+ .searchForPeers()
+ .orTimeout(10, TimeUnit.SECONDS)
+ .finish(
+ this::connectToKnownPeers,
+ error -> {
+ LOG.debug("Discovery failed", error);
+ connectToKnownPeers();
+ });
+ }
+
+ private void attemptConnection(final PeerAddress peerAddress) {
+ LOG.debug("Attempting to connect to {}", peerAddress.getId());
+ attemptedConnectionCounter.inc();
+ network
+ .connect(peerAddress)
+ .finish(
+ peer -> {
+ LOG.debug("Successfully connected to peer {}", peer.getId());
+ successfulConnectionCounter.inc();
+ peer.subscribeDisconnect(
+ (reason, locallyInitiated) -> peerPools.forgetPeer(peer.getId()));
+ },
+ error -> {
+ LOG.debug(() -> "Failed to connect to peer: " + peerAddress.getId(), error);
+ failedConnectionCounter.inc();
+ peerPools.forgetPeer(peerAddress.getId());
+ });
+ }
+
+ private void onPeerConnected(final Peer peer) {
+ peerSelectionStrategy
+ .selectPeersToDisconnect(network, peerPools)
+ .forEach(
+ peerToDrop ->
+ peerToDrop.disconnectCleanly(DisconnectReason.TOO_MANY_PEERS).reportExceptions());
+ }
+
+ @Override
+ protected SafeFuture doStop() {
+ network.unsubscribeConnect(peerConnectedSubscriptionId);
+ final Cancellable peerSearchTask = this.periodicPeerSearch;
+ if (peerSearchTask != null) {
+ peerSearchTask.cancel();
+ }
+ return SafeFuture.COMPLETE;
+ }
+
+ public synchronized void addStaticPeer(final PeerAddress peerAddress) {
+ if (!staticPeers.contains(peerAddress)) {
+ staticPeers.add(peerAddress);
+ createPersistentConnection(peerAddress);
+ }
+ }
+
+ private void createPersistentConnection(final PeerAddress peerAddress) {
+ maintainPersistentConnection(peerAddress).reportExceptions();
+ }
+
+ private SafeFuture maintainPersistentConnection(final PeerAddress peerAddress) {
+ if (!isRunning()) {
+ // We've been stopped so halt the process.
+ return new SafeFuture<>();
+ }
+ LOG.debug("Connecting to peer {}", peerAddress);
+ peerPools.addPeerToPool(peerAddress.getId(), PeerPool.STATIC);
+ attemptedConnectionCounter.inc();
+ return network
+ .connect(peerAddress)
+ .thenApply(
+ peer -> {
+ LOG.debug("Connection to peer {} was successful", peer.getId());
+ successfulConnectionCounter.inc();
+ peer.subscribeDisconnect(
+ (reason, locallyInitiated) -> {
+ LOG.debug(
+ "Peer {} disconnected. Will try to reconnect in {} sec",
+ peerAddress,
+ RECONNECT_TIMEOUT.toSeconds());
+ asyncRunner
+ .runAfterDelay(
+ () -> maintainPersistentConnection(peerAddress), RECONNECT_TIMEOUT)
+ .reportExceptions();
+ });
+ return peer;
+ })
+ .exceptionallyCompose(
+ error -> {
+ LOG.debug(
+ "Connection to {} failed: {}. Will retry in {} sec",
+ peerAddress,
+ error,
+ RECONNECT_TIMEOUT.toSeconds());
+ failedConnectionCounter.inc();
+ return asyncRunner.runAfterDelay(
+ () -> maintainPersistentConnection(peerAddress), RECONNECT_TIMEOUT);
+ });
+ }
+
+ public void addPeerPredicate(final Predicate predicate) {
+ peerPredicates.add(predicate);
+ }
+
+ private boolean isPeerValid(DiscoveryPeer peer) {
+ return !peer.getNodeAddress().getAddress().isAnyLocalAddress()
+ && peerPredicates.stream().allMatch(predicate -> predicate.test(peer));
+ }
+}
diff --git a/src/org/minima/system/network/base/DelayedExecutorAsyncRunner.java b/src/org/minima/system/network/base/DelayedExecutorAsyncRunner.java
new file mode 100644
index 000000000..eff7cf3b3
--- /dev/null
+++ b/src/org/minima/system/network/base/DelayedExecutorAsyncRunner.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import com.google.common.annotations.VisibleForTesting;
+import java.time.Duration;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.TimeUnit;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * An AsyncRunner that uses the common ForkJoinPool so that it is guaranteed not to leak threads
+ * even if the test doesn't shut it down.
+ */
+public class DelayedExecutorAsyncRunner implements AsyncRunner {
+ private static final Logger LOG = LogManager.getLogger();
+ private final ExecutorFactory executorFactory;
+
+ private DelayedExecutorAsyncRunner(ExecutorFactory executorFactory) {
+ this.executorFactory = executorFactory;
+ }
+
+ public static DelayedExecutorAsyncRunner create() {
+ return new DelayedExecutorAsyncRunner(CompletableFuture::delayedExecutor);
+ }
+
+ @Override
+ public SafeFuture runAsync(final ExceptionThrowingFutureSupplier action) {
+ final Executor executor = getAsyncExecutor();
+ return runAsync(action, executor);
+ }
+
+ @Override
+ public SafeFuture runAfterDelay(
+ ExceptionThrowingFutureSupplier action, Duration delay) {
+ final Executor executor = getDelayedExecutor(delay.toMillis(), TimeUnit.MILLISECONDS);
+ return runAsync(action, executor);
+ }
+
+ @Override
+ public void shutdown() {}
+
+ @VisibleForTesting
+ SafeFuture runAsync(
+ final ExceptionThrowingFutureSupplier action, final Executor executor) {
+ final SafeFuture result = new SafeFuture<>();
+ try {
+ executor.execute(() -> SafeFuture.of(action).propagateTo(result));
+ } catch (final RejectedExecutionException ex) {
+ LOG.debug("shutting down ", ex);
+ } catch (final Throwable t) {
+ result.completeExceptionally(t);
+ }
+ return result;
+ }
+
+ private Executor getAsyncExecutor() {
+ return getDelayedExecutor(-1, TimeUnit.SECONDS);
+ }
+
+ private Executor getDelayedExecutor(long delayAmount, TimeUnit delayUnit) {
+ return executorFactory.create(delayAmount, delayUnit);
+ }
+
+ private interface ExecutorFactory {
+ Executor create(long delayAmount, TimeUnit delayUnit);
+ }
+}
diff --git a/src/org/minima/system/network/base/DelegatingP2PNetwork.java b/src/org/minima/system/network/base/DelegatingP2PNetwork.java
new file mode 100644
index 000000000..7733df2bc
--- /dev/null
+++ b/src/org/minima/system/network/base/DelegatingP2PNetwork.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2019 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+// import org.apache.tuweni.bytes.Bytes;
+// import tech.pegasys.teku.infrastructure.async.SafeFuture;
+// import tech.pegasys.teku.networking.p2p.discovery.DiscoveryPeer;
+// import tech.pegasys.teku.networking.p2p.gossip.TopicChannel;
+// import tech.pegasys.teku.networking.p2p.gossip.TopicHandler;
+// import tech.pegasys.teku.networking.p2p.gossip.config.GossipTopicsScoringConfig;
+// import tech.pegasys.teku.networking.p2p.peer.NodeId;
+// import tech.pegasys.teku.networking.p2p.peer.Peer;
+
+import org.apache.tuweni.bytes.Bytes;
+import org.minima.system.network.base.gossip.TopicChannel;
+import org.minima.system.network.base.gossip.TopicHandler;
+import org.minima.system.network.base.gossip.config.GossipTopicsScoringConfig;
+import org.minima.system.network.base.peer.DiscoveryPeer;
+import org.minima.system.network.base.peer.NodeId;
+import org.minima.system.network.base.peer.Peer;
+import org.minima.system.network.base.peer.PeerAddress;
+
+public abstract class DelegatingP2PNetwork implements P2PNetwork {
+ private final P2PNetwork network;
+
+ protected DelegatingP2PNetwork(final P2PNetwork network) {
+ this.network = network;
+ }
+
+ @Override
+ public SafeFuture connect(final PeerAddress peer) {
+ return network.connect(peer);
+ }
+
+ @Override
+ public PeerAddress createPeerAddress(final DiscoveryPeer discoveryPeer) {
+ return network.createPeerAddress(discoveryPeer);
+ }
+
+ @Override
+ public NodeId parseNodeId(final String nodeId) {
+ return network.parseNodeId(nodeId);
+ }
+
+ @Override
+ public boolean isConnected(final PeerAddress peerAddress) {
+ return network.isConnected(peerAddress);
+ }
+
+ @Override
+ public Bytes getPrivateKey() {
+ return network.getPrivateKey();
+ }
+
+ @Override
+ public PeerAddress createPeerAddress(final String peerAddress) {
+ return network.createPeerAddress(peerAddress);
+ }
+
+ @Override
+ public int getPeerCount() {
+ return network.getPeerCount();
+ }
+
+ @Override
+ public String getNodeAddress() {
+ return network.getNodeAddress();
+ }
+
+ @Override
+ public NodeId getNodeId() {
+ return network.getNodeId();
+ }
+
+ @Override
+ public Optional getEnr() {
+ return network.getEnr();
+ }
+
+ @Override
+ public Optional getDiscoveryAddress() {
+ return network.getDiscoveryAddress();
+ }
+
+ @Override
+ public int getListenPort() {
+ return network.getListenPort();
+ }
+
+ @Override
+ public SafeFuture start() {
+ return network.start();
+ }
+
+ @Override
+ public SafeFuture stop() {
+ return network.stop();
+ }
+
+ @Override
+ public SafeFuture gossip(final String topic, final Bytes data) {
+ return network.gossip(topic, data);
+ }
+
+ @Override
+ public TopicChannel subscribe(final String topic, final TopicHandler topicHandler) {
+ return network.subscribe(topic, topicHandler);
+ }
+
+ @Override
+ public Map> getSubscribersByTopic() {
+ return network.getSubscribersByTopic();
+ }
+
+ @Override
+ public void updateGossipTopicScoring(final GossipTopicsScoringConfig config) {
+ network.updateGossipTopicScoring(config);
+ }
+}
diff --git a/src/org/minima/system/network/base/DiscV5Service.java b/src/org/minima/system/network/base/DiscV5Service.java
new file mode 100644
index 000000000..3e85ae9cf
--- /dev/null
+++ b/src/org/minima/system/network/base/DiscV5Service.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+//import static tech.pegasys.teku.util.config.Constants.ATTESTATION_SUBNET_COUNT;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import org.apache.tuweni.bytes.Bytes;
+import org.minima.system.network.base.peer.DiscoveryPeer;
+import org.minima.system.network.base.peer.MultiaddrUtil;
+import org.minima.system.network.base.ssz.SszBitvector;
+import org.apache.tuweni.units.bigints.UInt64;
+import org.ethereum.beacon.discovery.DiscoverySystem;
+import org.ethereum.beacon.discovery.DiscoverySystemBuilder;
+import org.ethereum.beacon.discovery.schema.EnrField;
+import org.ethereum.beacon.discovery.schema.NodeRecord;
+import org.ethereum.beacon.discovery.schema.NodeRecordBuilder;
+import org.ethereum.beacon.discovery.schema.NodeRecordInfo;
+import org.ethereum.beacon.discovery.schema.NodeStatus;
+import org.ethereum.beacon.discovery.storage.NewAddressHandler;
+//import tech.pegasys.teku.infrastructure.async.SafeFuture;
+
+// import tech.pegasys.teku.networking.p2p.discovery.DiscoveryConfig;
+// import tech.pegasys.teku.networking.p2p.discovery.DiscoveryPeer;
+// import tech.pegasys.teku.networking.p2p.discovery.DiscoveryService;
+// import tech.pegasys.teku.networking.p2p.libp2p.MultiaddrUtil;
+// import tech.pegasys.teku.networking.p2p.network.config.NetworkConfig;
+// import tech.pegasys.teku.service.serviceutils.Service;
+// import tech.pegasys.teku.ssz.collections.SszBitvector;
+// import tech.pegasys.teku.ssz.schema.collections.SszBitvectorSchema;
+// import tech.pegasys.teku.storage.store.KeyValueStore;
+import org.minima.system.network.base.ssz.SszBitvectorSchema;
+
+public class DiscV5Service extends Service implements DiscoveryService {
+ private static final String SEQ_NO_STORE_KEY = "local-enr-seqno";
+ static final SszBitvectorSchema SUBNET_SUBSCRIPTIONS_SCHEMA =
+ SszBitvectorSchema.create(DiscoveryNetwork.ATTESTATION_SUBNET_COUNT);
+
+ public static DiscoveryService create(
+ final DiscoveryConfig discoConfig,
+ final NetworkConfig p2pConfig,
+ final KeyValueStore kvStore,
+ final Bytes privateKey) {
+ return new DiscV5Service(discoConfig, p2pConfig, kvStore, privateKey);
+ }
+
+ private final DiscoverySystem discoverySystem;
+ private final KeyValueStore kvStore;
+
+ private static final Logger LOG = LogManager.getLogger(DiscV5Service.class);
+
+ private DiscV5Service(
+ final DiscoveryConfig discoConfig,
+ NetworkConfig p2pConfig,
+ KeyValueStore kvStore,
+ final Bytes privateKey) {
+ final String listenAddress = p2pConfig.getNetworkInterface();
+ final int listenPort = p2pConfig.getListenPort();
+ final String advertisedAddress = p2pConfig.getAdvertisedIp();
+ final int advertisedPort = p2pConfig.getAdvertisedPort();
+ final List bootnodes = discoConfig.getBootnodes();
+ final UInt64 seqNo =
+ kvStore.get(SEQ_NO_STORE_KEY).map(UInt64::fromBytes).orElse(UInt64.ZERO).add(1);
+ final NewAddressHandler maybeUpdateNodeRecordHandler =
+ maybeUpdateNodeRecord(p2pConfig.hasUserExplicitlySetAdvertisedIp());
+ discoverySystem =
+ new DiscoverySystemBuilder()
+ .listen(listenAddress, listenPort)
+ .privateKey(privateKey)
+ .bootnodes(bootnodes.toArray(new String[0]))
+ .localNodeRecord(
+ new NodeRecordBuilder()
+ .privateKey(privateKey)
+ .address(advertisedAddress, advertisedPort)
+ .seq(seqNo)
+ .build())
+ .newAddressHandler(maybeUpdateNodeRecordHandler)
+ .localNodeRecordListener(this::localNodeRecordUpdated)
+ .build();
+ this.kvStore = kvStore;
+ }
+
+ private NewAddressHandler maybeUpdateNodeRecord(boolean userExplicitlySetAdvertisedIpOrPort) {
+ return (oldRecord, proposedNewRecord) -> {
+ if (userExplicitlySetAdvertisedIpOrPort) {
+ return Optional.of(oldRecord);
+ } else {
+ return Optional.of(proposedNewRecord);
+ }
+ };
+ }
+
+ private void localNodeRecordUpdated(NodeRecord oldRecord, NodeRecord newRecord) {
+ LOG.info("Updating NodeRecord for " + newRecord.getNodeId() + "(" + newRecord.getTcpAddress() + ")");
+ kvStore.put(SEQ_NO_STORE_KEY, newRecord.getSeq().toBytes());
+ }
+
+ @Override
+ protected SafeFuture doStart() {
+ LOG.info("Starting discovery system");
+ return SafeFuture.of(discoverySystem.start());
+ }
+
+ @Override
+ protected SafeFuture doStop() {
+ LOG.info("Stopping discovery system");
+ discoverySystem.stop();
+ return SafeFuture.completedFuture(null);
+ }
+
+ @Override
+ public Stream streamKnownPeers() {
+// LOG.info("Returning all active nodes as known peers - " + activeNodes().count());
+ return activeNodes().map(NodeRecordConverter::convertToDiscoveryPeer).flatMap(Optional::stream);
+ }
+
+ @Override
+ public SafeFuture searchForPeers() {
+ LOG.info("Searching for new peers");
+ return SafeFuture.of(discoverySystem.searchForNewPeers());
+ }
+
+ @Override
+ public Optional getEnr() {
+ return Optional.of(discoverySystem.getLocalNodeRecord().asEnr());
+ }
+
+ @Override
+ public Optional getDiscoveryAddress() {
+ final NodeRecord nodeRecord = discoverySystem.getLocalNodeRecord();
+ if (nodeRecord.getUdpAddress().isEmpty()) {
+ return Optional.empty();
+ }
+ final DiscoveryPeer discoveryPeer =
+ new DiscoveryPeer(
+ (Bytes) nodeRecord.get(EnrField.PKEY_SECP256K1),
+ nodeRecord.getUdpAddress().get(),
+ Optional.empty(),
+ SUBNET_SUBSCRIPTIONS_SCHEMA.getDefault());
+
+ return Optional.of(MultiaddrUtil.fromDiscoveryPeerAsUdp(discoveryPeer).toString());
+ }
+
+ @Override
+ public void updateCustomENRField(String fieldName, Bytes value) {
+ discoverySystem.updateCustomFieldValue(fieldName, value);
+ }
+
+ private Stream activeNodes() {
+ // LOG.info("Returning all nodes known by discovery system and active");
+ return discoverySystem
+ .streamKnownNodes()
+ .filter(record -> record.getStatus() == NodeStatus.ACTIVE)
+ .map(NodeRecordInfo::getNode);
+ }
+}
diff --git a/src/org/minima/system/network/base/DiscoveryConfig.java b/src/org/minima/system/network/base/DiscoveryConfig.java
new file mode 100644
index 000000000..0acf98428
--- /dev/null
+++ b/src/org/minima/system/network/base/DiscoveryConfig.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2021 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class DiscoveryConfig {
+ private final boolean isDiscoveryEnabled;
+ private final List staticPeers;
+ private final List bootnodes;
+ private final int minPeers;
+ private final int maxPeers;
+ private final int minRandomlySelectedPeers;
+
+ private DiscoveryConfig(
+ final boolean isDiscoveryEnabled,
+ final List staticPeers,
+ final List bootnodes,
+ final int minPeers,
+ final int maxPeers,
+ final int minRandomlySelectedPeers) {
+ this.isDiscoveryEnabled = isDiscoveryEnabled;
+ this.staticPeers = staticPeers;
+ this.bootnodes = bootnodes;
+ this.minPeers = minPeers;
+ this.maxPeers = maxPeers;
+ this.minRandomlySelectedPeers = minRandomlySelectedPeers;
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ public boolean isDiscoveryEnabled() {
+ return isDiscoveryEnabled;
+ }
+
+ public List getStaticPeers() {
+ return staticPeers;
+ }
+
+ public List getBootnodes() {
+ return bootnodes;
+ }
+
+ public int getMinPeers() {
+ return minPeers;
+ }
+
+ public int getMaxPeers() {
+ return maxPeers;
+ }
+
+ public int getMinRandomlySelectedPeers() {
+ return minRandomlySelectedPeers;
+ }
+
+ public static class Builder {
+ private Boolean isDiscoveryEnabled = true;
+ private List staticPeers = Collections.emptyList();
+ private List bootnodes = Collections.emptyList();
+ private int minPeers = 64;
+ private int maxPeers = 74;
+ private int minRandomlySelectedPeers = 2;
+
+ private Builder() {}
+
+ public Builder isDiscoveryEnabled(final Boolean discoveryEnabled) {
+ checkNotNull(discoveryEnabled);
+ isDiscoveryEnabled = discoveryEnabled;
+ return this;
+ }
+
+ public DiscoveryConfig build() {
+ return new DiscoveryConfig(
+ isDiscoveryEnabled, staticPeers, bootnodes, minPeers, maxPeers, minRandomlySelectedPeers);
+ }
+
+ public Builder staticPeers(final List staticPeers) {
+ checkNotNull(staticPeers);
+ this.staticPeers = staticPeers;
+ return this;
+ }
+
+ public Builder bootnodes(final List bootnodes) {
+ checkNotNull(bootnodes);
+ this.bootnodes = bootnodes;
+ return this;
+ }
+
+ public Builder minPeers(final Integer minPeers) {
+ checkNotNull(minPeers);
+ this.minPeers = minPeers;
+ return this;
+ }
+
+ public Builder maxPeers(final Integer maxPeers) {
+ checkNotNull(maxPeers);
+ this.maxPeers = maxPeers;
+ return this;
+ }
+
+ public Builder minRandomlySelectedPeers(final Integer minRandomlySelectedPeers) {
+ checkNotNull(minRandomlySelectedPeers);
+ this.minRandomlySelectedPeers = minRandomlySelectedPeers;
+ return this;
+ }
+ }
+}
diff --git a/src/org/minima/system/network/base/DiscoveryNetwork.java b/src/org/minima/system/network/base/DiscoveryNetwork.java
new file mode 100644
index 000000000..24ee7cfa8
--- /dev/null
+++ b/src/org/minima/system/network/base/DiscoveryNetwork.java
@@ -0,0 +1,255 @@
+
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import static java.util.stream.Collectors.toList;
+//import static tech.pegasys.teku.util.config.Constants.ATTESTATION_SUBNET_COUNT;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import com.google.common.io.ByteSink;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.minima.system.network.base.metrics.MetricsSystem;
+import org.minima.system.network.base.peer.DiscoveryPeer;
+import org.minima.system.network.base.peer.NodeId;
+import org.apache.tuweni.bytes.Bytes;
+import org.apache.tuweni.bytes.Bytes32;
+// import org.hyperledger.besu.plugin.services.MetricsSystem;
+// import tech.pegasys.teku.infrastructure.async.AsyncRunner;
+// import tech.pegasys.teku.infrastructure.async.SafeFuture;
+// import tech.pegasys.teku.infrastructure.logging.StatusLogger;
+// import tech.pegasys.teku.infrastructure.unsigned.UInt64;
+// import tech.pegasys.teku.networking.p2p.connection.ConnectionManager;
+// import tech.pegasys.teku.networking.p2p.connection.PeerSelectionStrategy;
+// import tech.pegasys.teku.networking.p2p.discovery.discv5.DiscV5Service;
+// import tech.pegasys.teku.networking.p2p.discovery.noop.NoOpDiscoveryService;
+// import tech.pegasys.teku.networking.p2p.network.DelegatingP2PNetwork;
+// import tech.pegasys.teku.networking.p2p.network.P2PNetwork;
+// import tech.pegasys.teku.networking.p2p.network.config.NetworkConfig;
+// import tech.pegasys.teku.networking.p2p.peer.NodeId;
+// import tech.pegasys.teku.networking.p2p.peer.Peer;
+// import tech.pegasys.teku.networking.p2p.peer.PeerConnectedSubscriber;
+// import tech.pegasys.teku.ssz.schema.collections.SszBitvectorSchema;
+// import tech.pegasys.teku.ssz.type.Bytes4;
+import org.minima.system.network.base.peer.Peer;
+import org.minima.system.network.base.peer.PeerConnectedSubscriber;
+import org.minima.system.network.base.peer.PeerSelectionStrategy;
+import org.minima.system.network.base.ssz.SszBitvectorSchema;
+
+// import tech.pegasys.teku.storage.store.KeyValueStore;
+
+public class DiscoveryNetwork extends DelegatingP2PNetwork
{
+ private static final Logger LOG = LogManager.getLogger(DiscoveryNetwork.class);
+
+ public static final String ATTESTATION_SUBNET_ENR_FIELD = "attnets";
+ public static final String ETH2_ENR_FIELD = "eth2";
+
+ // from tech.pegasys.teku.util.config.Constants.ATTESTATION_SUBNET_COUNT
+ public static final int ATTESTATION_SUBNET_COUNT = 64;
+
+ private final P2PNetwork
p2pNetwork;
+ private final DiscoveryService discoveryService;
+ private final ConnectionManager connectionManager;
+
+ private volatile Optional enrForkId = Optional.empty();
+
+ private String mENR;
+
+ DiscoveryNetwork(
+ final P2PNetwork p2pNetwork,
+ final DiscoveryService discoveryService,
+ final ConnectionManager connectionManager) {
+ super(p2pNetwork);
+ this.p2pNetwork = p2pNetwork;
+ this.discoveryService = discoveryService;
+ this.connectionManager = connectionManager;
+ initialize();
+ }
+
+ public void initialize() {
+ //TODO: set ENR data set by setpregenesisforkinfo
+ //setPreGenesisForkInfo();
+ //TODO: log this in another way
+ // getEnr().ifPresent(StatusLogger.STATUS_LOG::listeningForDiscv5PreGenesis);
+
+ // Set connection manager peer predicate so that we don't attempt to connect peers with
+ // different fork digests
+// connectionManager.addPeerPredicate(this::dontConnectPeersWithDifferentForkDigests);
+ }
+
+ public static
DiscoveryNetwork
create(
+ final MetricsSystem metricsSystem,
+ final AsyncRunner asyncRunner,
+ final KeyValueStore kvStore,
+ final P2PNetwork p2pNetwork,
+ final PeerSelectionStrategy peerSelectionStrategy,
+ final DiscoveryConfig discoveryConfig,
+ final NetworkConfig p2pConfig
+ ) {
+ final DiscoveryService discoveryService =
+ createDiscoveryService(discoveryConfig, p2pConfig, kvStore, Bytes.wrap(p2pNetwork.getPrivateKey()));
+ final ConnectionManager connectionManager =
+ new ConnectionManager(
+ metricsSystem,
+ discoveryService,
+ asyncRunner,
+ p2pNetwork,
+ peerSelectionStrategy,
+ discoveryConfig.getStaticPeers().stream()
+ .map(p2pNetwork::createPeerAddress)
+ .collect(toList()));
+ return new DiscoveryNetwork<>(p2pNetwork, discoveryService, connectionManager);
+ }
+
+ private static DiscoveryService createDiscoveryService(
+ final DiscoveryConfig discoConfig,
+ final NetworkConfig p2pConfig,
+ final KeyValueStore kvStore,
+ final Bytes privateKey) {
+ final DiscoveryService discoveryService;
+ if (discoConfig.isDiscoveryEnabled()) {
+ System.out.println("P2P: Starting DiscV5 service");
+ discoveryService = DiscV5Service.create(discoConfig, p2pConfig, kvStore, privateKey);
+ //discoveryService = new NoOpDiscoveryService();
+ } else {
+ System.out.println("P2P: Starting NoOp Disc service");
+ discoveryService = new NoOpDiscoveryService();
+ }
+ return discoveryService;
+ }
+
+ public String getENR() {
+ return mENR;
+ }
+
+ @Override
+ public SafeFuture start() {
+ return SafeFuture.allOfFailFast(p2pNetwork.start(), discoveryService.start())
+ .thenCompose(__ -> connectionManager.start())
+ .thenRun(() -> getEnr().ifPresent(
+ enr -> {
+ LOG.warn("logwarn: listening for discv5: " + enr);
+ System.out.println("sysout: listening for discv5: " + enr);
+ mENR = enr;
+ }));
+ } //::listeningForDiscv5
+
+ @Override
+ public SafeFuture stop() {
+ return connectionManager
+ .stop()
+ .handleComposed(
+ (__, err) -> {
+ if (err != null) {
+ LOG.warn("Error shutting down connection manager", err);
+ }
+ return SafeFuture.allOf(p2pNetwork.stop(), discoveryService.stop());
+ });
+ }
+
+ public void addStaticPeer(final String peerAddress) {
+ connectionManager.addStaticPeer(p2pNetwork.createPeerAddress(peerAddress));
+ }
+
+ @Override
+ public Optional getEnr() {
+ return discoveryService.getEnr();
+ }
+
+ @Override
+ public Optional getDiscoveryAddress() {
+ return discoveryService.getDiscoveryAddress();
+ }
+
+ public void setLongTermAttestationSubnetSubscriptions(Iterable subnetIds) {
+ discoveryService.updateCustomENRField(
+ ATTESTATION_SUBNET_ENR_FIELD,
+ SszBitvectorSchema.create(ATTESTATION_SUBNET_COUNT).ofBits(subnetIds).sszSerialize());
+ }
+
+ // public void setPreGenesisForkInfo() {
+ // final Bytes4 genesisForkVersion = spec.getGenesisSpecConfig().getGenesisForkVersion();
+ // final EnrForkId enrForkId =
+ // new EnrForkId(
+ // spec.getGenesisBeaconStateUtil().computeForkDigest(genesisForkVersion, Bytes32.ZERO),
+ // genesisForkVersion,
+ // SpecConfig.FAR_FUTURE_EPOCH);
+ // discoveryService.updateCustomENRField(ETH2_ENR_FIELD, enrForkId.sszSerialize());
+ // this.enrForkId = Optional.of(enrForkId);
+ // }
+
+ // public void setForkInfo(final ForkInfo currentForkInfo, final Optional nextForkInfo) {
+ // // If no future fork is planned, set next_fork_version = current_fork_version to signal this
+ // final Bytes4 nextVersion =
+ // nextForkInfo
+ // .map(Fork::getCurrent_version)
+ // .orElse(currentForkInfo.getFork().getCurrent_version());
+ // // If no future fork is planned, set next_fork_epoch = FAR_FUTURE_EPOCH to signal this
+ // final UInt64 nextForkEpoch =
+ // nextForkInfo.map(Fork::getEpoch).orElse(SpecConfig.FAR_FUTURE_EPOCH);
+
+ // final Bytes4 forkDigest = currentForkInfo.getForkDigest();
+ // final EnrForkId enrForkId = new EnrForkId(forkDigest, nextVersion, nextForkEpoch);
+ // final Bytes encodedEnrForkId = enrForkId.sszSerialize();
+
+ // discoveryService.updateCustomENRField(ETH2_ENR_FIELD, encodedEnrForkId);
+ // this.enrForkId = Optional.of(enrForkId);
+ // }
+
+ // private boolean dontConnectPeersWithDifferentForkDigests(DiscoveryPeer peer) {
+ // return enrForkId
+ // .map(EnrForkId::getForkDigest)
+ // .flatMap(
+ // localForkDigest ->
+ // peer.getEnrForkId()
+ // .map(EnrForkId::getForkDigest)
+ // .map(peerForkDigest -> peerForkDigest.equals(localForkDigest)))
+ // .orElse(false);
+ // }
+
+ @Override
+ public long subscribeConnect(final PeerConnectedSubscriber subscriber) {
+ return p2pNetwork.subscribeConnect(subscriber);
+ }
+
+ @Override
+ public void unsubscribeConnect(final long subscriptionId) {
+ p2pNetwork.unsubscribeConnect(subscriptionId);
+ }
+
+ @Override
+ public Optional
getPeer(final NodeId id) {
+ return p2pNetwork.getPeer(id);
+ }
+
+ @Override
+ public Stream
streamPeers() {
+ return p2pNetwork.streamPeers();
+ }
+
+ public Stream streamKnownDiscoveryPeers() {
+ return discoveryService.streamKnownPeers();
+ }
+
+ public int getP2PPeerCount() {
+ LibP2PNetwork net = (LibP2PNetwork) p2pNetwork;
+ return net.getPeerCount();
+ }
+
+}
+
diff --git a/src/org/minima/system/network/base/DiscoveryNetworkFactory.java b/src/org/minima/system/network/base/DiscoveryNetworkFactory.java
new file mode 100644
index 000000000..c63c773f3
--- /dev/null
+++ b/src/org/minima/system/network/base/DiscoveryNetworkFactory.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import java.net.BindException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import io.libp2p.core.crypto.PrivKey;
+
+// import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem;
+// import tech.pegasys.teku.infrastructure.async.DelayedExecutorAsyncRunner;
+// import tech.pegasys.teku.infrastructure.async.SafeFuture;
+// import tech.pegasys.teku.infrastructure.async.Waiter;
+// import tech.pegasys.teku.infrastructure.time.StubTimeProvider;
+// import tech.pegasys.teku.network.p2p.jvmlibp2p.PrivateKeyGenerator;
+// import tech.pegasys.teku.network.p2p.peer.SimplePeerSelectionStrategy;
+// import tech.pegasys.teku.networking.p2p.connection.PeerSelectionStrategy;
+// import tech.pegasys.teku.networking.p2p.connection.TargetPeerRange;
+// import tech.pegasys.teku.networking.p2p.discovery.DiscoveryConfig;
+// import tech.pegasys.teku.networking.p2p.discovery.DiscoveryNetwork;
+// import tech.pegasys.teku.networking.p2p.libp2p.LibP2PNetwork;
+// import tech.pegasys.teku.networking.p2p.network.config.NetworkConfig;
+// import tech.pegasys.teku.networking.p2p.peer.Peer;
+// import tech.pegasys.teku.networking.p2p.reputation.ReputationManager;
+// import tech.pegasys.teku.spec.Spec;
+// import tech.pegasys.teku.spec.SpecFactory;
+// import tech.pegasys.teku.storage.store.MemKeyValueStore;
+// import tech.pegasys.teku.util.config.Constants;
+import org.minima.system.network.base.metrics.NoOpMetricsSystem;
+import org.minima.system.network.base.peer.Peer;
+import org.minima.system.network.base.peer.PeerSelectionStrategy;
+import org.minima.system.network.base.peer.ReputationManager;
+import org.minima.system.network.base.peer.SimplePeerSelectionStrategy;
+import org.minima.system.network.base.peer.TargetPeerRange;
+
+public class DiscoveryNetworkFactory {
+
+ protected static final Logger LOG = LogManager.getLogger(DiscoveryNetworkFactory.class);
+ protected static final NoOpMetricsSystem METRICS_SYSTEM = new NoOpMetricsSystem();
+ private static final int MIN_PORT = 9000;
+ private static final int MAX_PORT = 12000;
+
+ private final List> networks = new ArrayList<>();
+
+ // from tech.pegasys.teku.util.config.Constants
+ public final class Constants {
+ public static final int REPUTATION_MANAGER_CAPACITY = 1024;
+ public static final int ATTESTATION_SUBNET_COUNT = 64;
+ }
+
+ public DiscoveryNetworkBuilder builder() {
+ return new DiscoveryNetworkBuilder();
+ }
+
+ public void stopAll() throws InterruptedException, ExecutionException, TimeoutException {
+ Waiter.waitFor(
+ SafeFuture.allOf(networks.stream().map(DiscoveryNetwork::stop).toArray(SafeFuture[]::new)));
+ }
+
+ public class DiscoveryNetworkBuilder {
+ private final List staticPeers = new ArrayList<>();
+ private final List bootnodes = new ArrayList<>();
+ private PrivKey privKey;
+
+ private DiscoveryNetworkBuilder() {}
+
+ public DiscoveryNetworkBuilder staticPeer(final String staticPeer) {
+ this.staticPeers.add(staticPeer);
+ return this;
+ }
+
+ public DiscoveryNetworkBuilder bootnode(final String bootnode) {
+ this.bootnodes.add(bootnode);
+ return this;
+ }
+
+ public DiscoveryNetworkBuilder setPrivKey(final PrivKey privKey) {
+ this.privKey = privKey;
+ return this;
+ }
+ public DiscoveryNetwork buildAndStart(int _port) throws Exception {
+ int attempt = 1;
+ while (true) {
+ final int port;
+ if(_port == 0) {
+ final Random random = new Random();
+ port = MIN_PORT + random.nextInt(MAX_PORT - MIN_PORT);
+ } else {
+ port = _port;
+ }
+ final DiscoveryConfig discoveryConfig =
+ DiscoveryConfig.builder().staticPeers(staticPeers).bootnodes(bootnodes).build();
+ final NetworkConfig config =
+ NetworkConfig.builder().listenPort(port).networkInterface("0.0.0.0").build();
+ final NoOpMetricsSystem metricsSystem = new NoOpMetricsSystem();
+ final ReputationManager reputationManager =
+ new ReputationManager(
+ metricsSystem,
+ StubTimeProvider.withTimeInSeconds(1000),
+ Constants.REPUTATION_MANAGER_CAPACITY);
+ final PeerSelectionStrategy peerSelectionStrategy =
+ new SimplePeerSelectionStrategy(new TargetPeerRange(20, 30, 0));
+
+ final DiscoveryNetwork network =
+ DiscoveryNetwork.create(
+ metricsSystem,
+ DelayedExecutorAsyncRunner.create(),
+ new MemKeyValueStore<>(),
+ new LibP2PNetwork(
+ DelayedExecutorAsyncRunner.create(),
+ config,
+ privKey,
+ reputationManager,
+ METRICS_SYSTEM,
+ Collections.emptyList(),
+ Collections.emptyList(),
+ (__1, __2) -> {
+ throw new UnsupportedOperationException();
+ },
+ topic -> true),
+ peerSelectionStrategy,
+ discoveryConfig,
+ config);
+ try {
+ network.start().get(5, TimeUnit.SECONDS);
+ networks.add(network);
+ return network;
+ } catch (final ExecutionException e) {
+ if (e.getCause() instanceof BindException) {
+ if (attempt > 10) {
+ throw new RuntimeException("Failed to find a free port after multiple attempts", e);
+ }
+ LOG.info(
+ "Port conflict detected, retrying with a new port. Original message: {}",
+ e.getMessage());
+ attempt++;
+ Waiter.waitFor(network.stop());
+ } else {
+ throw e;
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src/org/minima/system/network/base/DiscoveryService.java b/src/org/minima/system/network/base/DiscoveryService.java
new file mode 100644
index 000000000..184eb9935
--- /dev/null
+++ b/src/org/minima/system/network/base/DiscoveryService.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+import org.apache.tuweni.bytes.Bytes;
+//import tech.pegasys.teku.infrastructure.async.SafeFuture;
+import org.minima.system.network.base.peer.DiscoveryPeer;
+
+public interface DiscoveryService {
+
+ SafeFuture start();
+
+ SafeFuture stop();
+
+ Stream streamKnownPeers();
+
+ SafeFuture searchForPeers();
+
+ Optional getEnr();
+
+ Optional getDiscoveryAddress();
+
+ void updateCustomENRField(String fieldName, Bytes value);
+}
diff --git a/src/org/minima/system/network/base/EnrForkId.java b/src/org/minima/system/network/base/EnrForkId.java
new file mode 100644
index 000000000..08bf7670f
--- /dev/null
+++ b/src/org/minima/system/network/base/EnrForkId.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import org.minima.system.network.base.ssz.Bytes4;
+import org.minima.system.network.base.ssz.Container3;
+import org.minima.system.network.base.ssz.ContainerSchema3;
+import org.minima.system.network.base.ssz.SszBytes4;
+import org.minima.system.network.base.ssz.SszPrimitiveSchemas;
+import org.minima.system.network.base.ssz.SszUInt64;
+import org.minima.system.network.base.ssz.UInt64;
+import org.minima.system.network.base.ssz.TreeNode;
+
+// import tech.pegasys.teku.infrastructure.unsigned.UInt64;
+// import tech.pegasys.teku.ssz.containers.Container3;
+// import tech.pegasys.teku.ssz.containers.ContainerSchema3;
+// import tech.pegasys.teku.ssz.primitive.SszBytes4;
+// import tech.pegasys.teku.ssz.primitive.SszUInt64;
+// import tech.pegasys.teku.ssz.schema.SszPrimitiveSchemas;
+// import tech.pegasys.teku.ssz.tree.TreeNode;
+// import tech.pegasys.teku.ssz.type.Bytes4;
+
+public class EnrForkId extends Container3 {
+
+ public static class EnrForkIdSchema
+ extends ContainerSchema3 {
+
+ public EnrForkIdSchema() {
+ super(
+ "EnrForkId",
+ namedSchema("forkDigest", SszPrimitiveSchemas.BYTES4_SCHEMA),
+ namedSchema("nextForkVersion", SszPrimitiveSchemas.BYTES4_SCHEMA),
+ namedSchema("nextForkEpoch", SszPrimitiveSchemas.UINT64_SCHEMA));
+ }
+
+ @Override
+ public EnrForkId createFromBackingNode(TreeNode node) {
+ return new EnrForkId(this, node);
+ }
+ }
+
+ public static final EnrForkIdSchema SSZ_SCHEMA = new EnrForkIdSchema();
+
+ private EnrForkId(EnrForkIdSchema type, TreeNode backingNode) {
+ super(type, backingNode);
+ }
+
+ public EnrForkId(
+ final Bytes4 forkDigest, final Bytes4 nextForkVersion, final UInt64 nextForkEpoch) {
+ super(
+ SSZ_SCHEMA,
+ SszBytes4.of(forkDigest),
+ SszBytes4.of(nextForkVersion),
+ SszUInt64.of(nextForkEpoch));
+ }
+
+ public Bytes4 getForkDigest() {
+ return getField0().get();
+ }
+
+ public Bytes4 getNextForkVersion() {
+ return getField1().get();
+ }
+
+ public UInt64 getNextForkEpoch() {
+ return getField2().get();
+ }
+}
diff --git a/src/org/minima/system/network/base/ExceptionThrowingConsumer.java b/src/org/minima/system/network/base/ExceptionThrowingConsumer.java
new file mode 100644
index 000000000..2cc4ce007
--- /dev/null
+++ b/src/org/minima/system/network/base/ExceptionThrowingConsumer.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2021 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+public interface ExceptionThrowingConsumer {
+
+ void accept(V value) throws Throwable;
+}
diff --git a/src/org/minima/system/network/base/ExceptionThrowingFunction.java b/src/org/minima/system/network/base/ExceptionThrowingFunction.java
new file mode 100644
index 000000000..58bee42d1
--- /dev/null
+++ b/src/org/minima/system/network/base/ExceptionThrowingFunction.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+public interface ExceptionThrowingFunction {
+ O apply(I value) throws Throwable;
+}
diff --git a/src/org/minima/system/network/base/ExceptionThrowingFutureSupplier.java b/src/org/minima/system/network/base/ExceptionThrowingFutureSupplier.java
new file mode 100644
index 000000000..1648b11b3
--- /dev/null
+++ b/src/org/minima/system/network/base/ExceptionThrowingFutureSupplier.java
@@ -0,0 +1,8 @@
+
+package org.minima.system.network.base;
+
+import java.util.concurrent.CompletionStage;
+
+public interface ExceptionThrowingFutureSupplier {
+ CompletionStage get() throws Throwable;
+}
diff --git a/src/org/minima/system/network/base/ExceptionThrowingRunnable.java b/src/org/minima/system/network/base/ExceptionThrowingRunnable.java
new file mode 100644
index 000000000..4ea79c94a
--- /dev/null
+++ b/src/org/minima/system/network/base/ExceptionThrowingRunnable.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+public interface ExceptionThrowingRunnable {
+ void run() throws Throwable;
+}
diff --git a/src/org/minima/system/network/base/ExceptionThrowingSupplier.java b/src/org/minima/system/network/base/ExceptionThrowingSupplier.java
new file mode 100644
index 000000000..b7ac9b693
--- /dev/null
+++ b/src/org/minima/system/network/base/ExceptionThrowingSupplier.java
@@ -0,0 +1,6 @@
+
+package org.minima.system.network.base;
+
+public interface ExceptionThrowingSupplier {
+ O get() throws Throwable;
+}
diff --git a/src/org/minima/system/network/base/Firewall.java b/src/org/minima/system/network/base/Firewall.java
new file mode 100644
index 000000000..91bcaf37e
--- /dev/null
+++ b/src/org/minima/system/network/base/Firewall.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import io.netty.channel.ChannelHandler.Sharable;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.WriteBufferWaterMark;
+import io.netty.handler.timeout.WriteTimeoutException;
+import io.netty.handler.timeout.WriteTimeoutHandler;
+import java.time.Duration;
+import java.util.concurrent.TimeUnit;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+//import tech.pegasys.teku.infrastructure.async.FutureUtil;
+
+/**
+ * The very first Netty handler in the Libp2p connection pipeline. Sets up Netty Channel options and
+ * doing other duties preventing DoS attacks
+ */
+@Sharable
+public class Firewall extends ChannelInboundHandlerAdapter {
+ private static final Logger LOG = LogManager.getLogger();
+
+ private final Duration writeTimeout;
+
+ public Firewall(Duration writeTimeout) {
+ this.writeTimeout = writeTimeout;
+ }
+
+ @Override
+ public void handlerAdded(ChannelHandlerContext ctx) {
+ ctx.channel().config().setWriteBufferWaterMark(new WriteBufferWaterMark(100, 1024));
+ ctx.pipeline().addLast(new WriteTimeoutHandler(writeTimeout.toMillis(), TimeUnit.MILLISECONDS));
+ ctx.pipeline().addLast(new FirewallExceptionHandler());
+ }
+
+ @Override
+ public void channelWritabilityChanged(ChannelHandlerContext ctx) {
+ ctx.channel().config().setAutoRead(ctx.channel().isWritable());
+ ctx.fireChannelWritabilityChanged();
+ }
+
+ class FirewallExceptionHandler extends ChannelInboundHandlerAdapter {
+ @Override
+ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+ if (cause instanceof WriteTimeoutException) {
+ LOG.debug("Firewall closed channel by write timeout. No writes during " + writeTimeout);
+ } else {
+ LOG.debug("Error in Firewall, disconnecting" + cause);
+ FutureUtil.ignoreFuture(ctx.close());
+ }
+ }
+ }
+}
diff --git a/src/org/minima/system/network/base/FutureUtil.java b/src/org/minima/system/network/base/FutureUtil.java
new file mode 100644
index 000000000..c06646e8d
--- /dev/null
+++ b/src/org/minima/system/network/base/FutureUtil.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2019 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import java.time.Duration;
+import java.util.concurrent.Future;
+import java.util.function.Consumer;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class FutureUtil {
+ private static final Logger LOG = LogManager.getLogger();
+
+ public static void ignoreFuture(final Future future) {}
+
+ static void runWithFixedDelay(
+ AsyncRunner runner,
+ ExceptionThrowingRunnable runnable,
+ Cancellable task,
+ final Duration duration,
+ Consumer exceptionHandler) {
+
+ runner
+ .runAfterDelay(
+ () -> {
+ if (!task.isCancelled()) {
+ try {
+ runnable.run();
+ } catch (Throwable throwable) {
+ try {
+ exceptionHandler.accept(throwable);
+ } catch (Exception e) {
+ LOG.warn("Exception in exception handler", e);
+ }
+ } finally {
+ runWithFixedDelay(runner, runnable, task, duration, exceptionHandler);
+ }
+ }
+ },
+ duration)
+ .finish(() -> {}, exceptionHandler);
+ }
+
+ static Cancellable createCancellable() {
+ return new Cancellable() {
+ private volatile boolean cancelled;
+
+ @Override
+ public void cancel() {
+ cancelled = true;
+ }
+
+ @Override
+ public boolean isCancelled() {
+ return cancelled;
+ }
+ };
+ }
+}
diff --git a/src/org/minima/system/network/base/InvalidConfigurationException.java b/src/org/minima/system/network/base/InvalidConfigurationException.java
new file mode 100644
index 000000000..b239e9db5
--- /dev/null
+++ b/src/org/minima/system/network/base/InvalidConfigurationException.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+public class InvalidConfigurationException extends RuntimeException {
+ public InvalidConfigurationException(final String message) {
+ super(message);
+ }
+
+ public InvalidConfigurationException(final String message, final Throwable cause) {
+ super(message, cause);
+ }
+
+ public InvalidConfigurationException(final Throwable cause) {
+ super(cause.getMessage(), cause);
+ }
+}
diff --git a/src/org/minima/system/network/base/KeyValueStore.java b/src/org/minima/system/network/base/KeyValueStore.java
new file mode 100644
index 000000000..95d07ca62
--- /dev/null
+++ b/src/org/minima/system/network/base/KeyValueStore.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import java.util.Optional;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Generic simple key-value store interface Both key and value are not allowed to be null
+ *
+ * @param key type
+ * @param value type
+ */
+public interface KeyValueStore {
+
+ /** Puts a new value. If the value is {@code null} then the entry is removed if exist */
+ void put(@NotNull TKey key, @NotNull TValue value);
+
+ /** Removes entry with the specified key */
+ void remove(@NotNull TKey key);
+
+ /**
+ * Returns a value corresponding to the key or {{@link Optional#empty()}} if entry doesn't exist
+ * in the store
+ */
+ Optional get(@NotNull TKey key);
+
+ /**
+ * Performs batch store update.
+ *
+ * The implementation may override this default method and declare it to be an atomic store
+ * update. Though this generic interface makes no restrictions on atomicity of this method
+ */
+ default void updateAll(Iterable> data) {
+ data.forEach(
+ update -> {
+ if (update.getType() == UpdateType.UPDATE) {
+ put(update.getKey(), update.getValue());
+ } else if (update.getType() == UpdateType.REMOVE) {
+ remove(update.getKey());
+ } else {
+ throw new IllegalArgumentException("Unknown type: " + update.getType());
+ }
+ });
+ }
+
+ enum UpdateType {
+ UPDATE,
+ REMOVE
+ }
+
+ /** Represents a batched update entry */
+ class EntryUpdate {
+ private final UpdateType type;
+ private final K key;
+ private final V value;
+
+ public static EntryUpdate update(K key, V value) {
+ return new EntryUpdate<>(UpdateType.UPDATE, key, value);
+ }
+
+ public static EntryUpdate remove(K key) {
+ return new EntryUpdate<>(UpdateType.REMOVE, key, null);
+ }
+
+ private EntryUpdate(UpdateType type, K key, V value) {
+ this.type = type;
+ this.key = key;
+ this.value = value;
+ }
+
+ public UpdateType getType() {
+ return type;
+ }
+
+ public K getKey() {
+ return key;
+ }
+
+ public V getValue() {
+ if (getType() != UpdateType.UPDATE) {
+ throw new IllegalStateException("No value for this update");
+ }
+ return value;
+ }
+ }
+}
diff --git a/src/org/minima/system/network/base/LRUCache.java b/src/org/minima/system/network/base/LRUCache.java
new file mode 100644
index 000000000..34da71967
--- /dev/null
+++ b/src/org/minima/system/network/base/LRUCache.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+//import tech.pegasys.teku.infrastructure.collections.LimitedMap;
+
+import org.minima.system.network.base.ssz.Cache;
+
+/**
+ * Cache made around LRU-map with fixed size, removing eldest entries (by added) when the space is
+ * over
+ *
+ * @param Keys type
+ * @param Values type
+ */
+public class LRUCache implements Cache {
+
+ private final Map cacheData;
+ private final int maxCapacity;
+
+ /**
+ * Creates cache
+ *
+ * @param capacity Size of the cache
+ */
+ public LRUCache(int capacity) {
+ this(capacity, Collections.emptyMap());
+ }
+
+ private LRUCache(int capacity, Map initialCachedContent) {
+ this.maxCapacity = capacity;
+ Map cacheMap = LimitedMap.create(maxCapacity);
+ // copy safely, initialCachedContent is always a SynchronizedMap instance
+ synchronized (initialCachedContent) {
+ cacheMap.putAll(initialCachedContent);
+ }
+ this.cacheData = cacheMap;
+ }
+
+ @Override
+ public Cache copy() {
+ return new LRUCache<>(maxCapacity, cacheData);
+ }
+
+ /**
+ * Queries value from the cache. If it's not found there, fallback function is used to calculate
+ * value. After calculation result is put in cache and returned.
+ *
+ * @param key Key to query
+ * @param fallback Fallback function for calculation of the result in case of missed cache entry
+ * @return expected value result for provided key
+ */
+ @Override
+ public V get(K key, Function fallback) {
+ V result = cacheData.get(key);
+
+ if (result == null) {
+ result = fallback.apply(key);
+ if (result != null) {
+ cacheData.put(key, result);
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ public Optional getCached(K key) {
+ return Optional.ofNullable(cacheData.get(key));
+ }
+
+ @Override
+ public void invalidate(K key) {
+ cacheData.remove(key);
+ }
+
+ @Override
+ public void clear() {
+ cacheData.clear();
+ }
+
+ @Override
+ public int size() {
+ return cacheData.size();
+ }
+}
diff --git a/src/org/minima/system/network/base/LibP2PNetwork.java b/src/org/minima/system/network/base/LibP2PNetwork.java
new file mode 100644
index 000000000..51381dcfd
--- /dev/null
+++ b/src/org/minima/system/network/base/LibP2PNetwork.java
@@ -0,0 +1,332 @@
+/*
+ * Copyright 2019 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import static org.minima.system.network.base.SafeFuture.failedFuture;
+//import static tech.pegasys.teku.infrastructure.logging.StatusLogger.STATUS_LOG;
+
+import identify.pb.IdentifyOuterClass;
+import io.libp2p.core.Host;
+import io.libp2p.core.PeerId;
+import io.libp2p.core.crypto.PrivKey;
+import io.libp2p.core.dsl.Builder.Defaults;
+import io.libp2p.core.dsl.BuilderJKt;
+import io.libp2p.core.multiformats.Multiaddr;
+import io.libp2p.core.multistream.ProtocolBinding;
+import io.libp2p.core.mux.StreamMuxerProtocol;
+import io.libp2p.etc.types.ByteArrayExtKt;
+//import io.libp2p.etc.util.P2PService.PeerHandler;
+import io.libp2p.protocol.Identify;
+import io.libp2p.protocol.Ping;
+import io.libp2p.security.noise.NoiseXXSecureChannel;
+import io.libp2p.transport.tcp.TcpTransport;
+import io.netty.handler.logging.LogLevel;
+import java.net.InetSocketAddress;
+import java.time.Duration;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Stream;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.tuweni.bytes.Bytes;
+import org.minima.system.network.base.gossip.PreparedGossipMessageFactory;
+import org.minima.system.network.base.gossip.TopicChannel;
+import org.minima.system.network.base.gossip.TopicHandler;
+import org.minima.system.network.base.gossip.config.GossipTopicsScoringConfig;
+import org.minima.system.network.base.libp2p.gossip.GossipTopicFilter;
+import org.minima.system.network.base.libp2p.gossip.LibP2PGossipNetwork;
+import org.minima.system.network.base.metrics.MetricsSystem;
+import org.minima.system.network.base.peer.DiscoveryPeer;
+import org.minima.system.network.base.peer.LibP2PNodeId;
+import org.minima.system.network.base.peer.MultiaddrPeerAddress;
+import org.minima.system.network.base.peer.MultiaddrUtil;
+import org.minima.system.network.base.peer.NodeId;
+//import org.hyperledger.besu.plugin.services.MetricsSystem;
+// import tech.pegasys.teku.infrastructure.async.AsyncRunner;
+// import tech.pegasys.teku.infrastructure.async.SafeFuture;
+// import tech.pegasys.teku.infrastructure.version.VersionProvider;
+// import tech.pegasys.teku.networking.p2p.discovery.DiscoveryPeer;
+// import tech.pegasys.teku.networking.p2p.gossip.PreparedGossipMessageFactory;
+// import tech.pegasys.teku.networking.p2p.gossip.TopicChannel;
+// import tech.pegasys.teku.networking.p2p.gossip.TopicHandler;
+// import tech.pegasys.teku.networking.p2p.gossip.config.GossipTopicsScoringConfig;
+// import tech.pegasys.teku.networking.p2p.libp2p.gossip.GossipTopicFilter;
+// import tech.pegasys.teku.networking.p2p.libp2p.gossip.LibP2PGossipNetwork;
+// import tech.pegasys.teku.networking.p2p.libp2p.rpc.RpcHandler;
+// import tech.pegasys.teku.networking.p2p.network.P2PNetwork;
+// import tech.pegasys.teku.networking.p2p.network.PeerAddress;
+// import tech.pegasys.teku.networking.p2p.network.PeerHandler;
+// import tech.pegasys.teku.networking.p2p.network.config.NetworkConfig;
+// import tech.pegasys.teku.networking.p2p.peer.NodeId;
+// import tech.pegasys.teku.networking.p2p.peer.Peer;
+// import tech.pegasys.teku.networking.p2p.peer.PeerConnectedSubscriber;
+// import tech.pegasys.teku.networking.p2p.reputation.ReputationManager;
+// import tech.pegasys.teku.networking.p2p.rpc.RpcMethod;
+import org.minima.system.network.base.peer.Peer;
+import org.minima.system.network.base.peer.PeerAddress;
+import org.minima.system.network.base.peer.PeerConnectedSubscriber;
+import org.minima.system.network.base.peer.PeerManager;
+import org.minima.system.network.base.peer.PeerHandler;
+import org.minima.system.network.base.peer.ReputationManager;
+import org.minima.system.network.base.peer.RpcHandler;
+import org.minima.system.network.base.peer.RpcMethod;
+
+public class LibP2PNetwork implements P2PNetwork {
+
+ private static final Logger LOG = LogManager.getLogger(LibP2PNetwork.class);
+ private static final int REMOTE_OPEN_STREAMS_RATE_LIMIT = 256;
+ private static final int REMOTE_PARALLEL_OPEN_STREAMS_COUNT_LIMIT = 256;
+
+ private final PrivKey privKey;
+ private final NodeId nodeId;
+
+ private final Host host;
+ private final PeerManager peerManager;
+ private final Multiaddr advertisedAddr;
+ private final LibP2PGossipNetwork gossipNetwork;
+
+ private final AtomicReference state = new AtomicReference<>(State.IDLE);
+ private final Map rpcHandlers = new ConcurrentHashMap<>();
+ private final int listenPort;
+
+ public LibP2PNetwork(
+ final AsyncRunner asyncRunner,
+ final NetworkConfig config,
+ final PrivKey privKey,
+ final ReputationManager reputationManager,
+ final MetricsSystem metricsSystem,
+ final List rpcMethods,
+ final List peerHandlers,
+ final PreparedGossipMessageFactory defaultMessageFactory,
+ final GossipTopicFilter gossipTopicFilter) {
+
+ this.privKey = privKey;
+ this.nodeId = new LibP2PNodeId(PeerId.fromPubKey(privKey.publicKey()));
+
+ System.out.println("LibP2PNetwork - privKey = " + privKey.toString());
+ System.out.println("LibP2PNetwork - nodeId = " + nodeId);
+ advertisedAddr =
+ MultiaddrUtil.fromInetSocketAddress(
+ new InetSocketAddress(config.getAdvertisedIp(), config.getAdvertisedPort()), nodeId);
+ this.listenPort = config.getListenPort();
+
+ // Setup gossip
+ gossipNetwork =
+ LibP2PGossipNetwork.create(
+ metricsSystem,
+ config.getGossipConfig(),
+ defaultMessageFactory,
+ gossipTopicFilter,
+ config.getWireLogsConfig().isLogWireGossip());
+
+ // Setup rpc methods
+ rpcMethods.forEach(method -> rpcHandlers.put(method, new RpcHandler(asyncRunner, method)));
+
+ // Setup peers
+ peerManager = new PeerManager(metricsSystem, reputationManager, peerHandlers, rpcHandlers);
+
+ final Multiaddr listenAddr =
+ MultiaddrUtil.fromInetSocketAddress(
+ new InetSocketAddress(config.getNetworkInterface(), config.getListenPort()));
+ host =
+ BuilderJKt.hostJ(
+ Defaults.None,
+ b -> {
+ b.getIdentity().setFactory(() -> privKey);
+ b.getTransports().add(TcpTransport::new);
+ b.getSecureChannels().add(NoiseXXSecureChannel::new);
+ b.getMuxers().add(StreamMuxerProtocol.getMplex());
+
+ b.getNetwork().listen(listenAddr.toString());
+
+ b.getProtocols().addAll(getDefaultProtocols());
+ b.getProtocols().addAll(rpcHandlers.values());
+
+ if (config.getWireLogsConfig().isLogWireCipher()) {
+ b.getDebug().getBeforeSecureHandler().addLogger(LogLevel.DEBUG, "wire.ciphered");
+ }
+ Firewall firewall = new Firewall(Duration.ofSeconds(30));
+ b.getDebug().getBeforeSecureHandler().addNettyHandler(firewall);
+
+ if (config.getWireLogsConfig().isLogWirePlain()) {
+ b.getDebug().getAfterSecureHandler().addLogger(LogLevel.DEBUG, "wire.plain");
+ }
+ if (config.getWireLogsConfig().isLogWireMuxFrames()) {
+ b.getDebug().getMuxFramesHandler().addLogger(LogLevel.DEBUG, "wire.mux");
+ }
+
+ b.getConnectionHandlers().add(peerManager);
+
+ MplexFirewall mplexFirewall =
+ new MplexFirewall(
+ REMOTE_OPEN_STREAMS_RATE_LIMIT, REMOTE_PARALLEL_OPEN_STREAMS_COUNT_LIMIT);
+ b.getDebug().getMuxFramesHandler().addHandler(mplexFirewall);
+ });
+ }
+
+ private List> getDefaultProtocols() {
+ final Ping ping = new Ping();
+ IdentifyOuterClass.Identify identifyMsg =
+ IdentifyOuterClass.Identify.newBuilder()
+ .setProtocolVersion("ipfs/0.1.0")
+ .setAgentVersion("Minima_0.98.0-testss-p2p-Zulu-OpenJDK-11-AARCH64")
+ .setPublicKey(ByteArrayExtKt.toProtobuf(privKey.publicKey().bytes()))
+ .addListenAddrs(ByteArrayExtKt.toProtobuf(advertisedAddr.getBytes()))
+ .setObservedAddr(ByteArrayExtKt.toProtobuf(advertisedAddr.getBytes()))
+ .addAllProtocols(ping.getProtocolDescriptor().getAnnounceProtocols())
+ .addAllProtocols(
+ gossipNetwork.getGossip().getProtocolDescriptor().getAnnounceProtocols())
+ .build();
+ return List.of(ping, new Identify(identifyMsg), gossipNetwork.getGossip());
+ }
+
+ @Override
+ public SafeFuture start() {
+ if (!state.compareAndSet(State.IDLE, State.RUNNING)) {
+ return SafeFuture.failedFuture(new IllegalStateException("Network already started"));
+ }
+ LOG.info("Starting libp2p network...");
+ return SafeFuture.of(host.start())
+ .thenApply(
+ i -> {
+ //STATUS_LOG.listeningForLibP2P(getNodeAddress());
+ LOG.debug("Listening for LibP2P - " + getNodeAddress());
+ return null;
+ });
+ }
+
+ @Override
+ public String getNodeAddress() {
+ return advertisedAddr.toString();
+ }
+
+ @Override
+ public SafeFuture connect(final PeerAddress peer) {
+ return peer.as(MultiaddrPeerAddress.class)
+ .map(staticPeer -> peerManager.connect(staticPeer, host.getNetwork()))
+ .orElseGet(
+ () ->
+ failedFuture(
+ new IllegalArgumentException(
+ "Unsupported peer address: " + peer.getClass().getName())));
+ }
+
+ @Override
+ public PeerAddress createPeerAddress(final String peerAddress) {
+ return MultiaddrPeerAddress.fromAddress(peerAddress);
+ }
+
+ @Override
+ public PeerAddress createPeerAddress(final DiscoveryPeer discoveryPeer) {
+ return MultiaddrPeerAddress.fromDiscoveryPeer(discoveryPeer);
+ }
+
+ @Override
+ public long subscribeConnect(final PeerConnectedSubscriber subscriber) {
+ return peerManager.subscribeConnect(subscriber);
+ }
+
+ @Override
+ public void unsubscribeConnect(final long subscriptionId) {
+ peerManager.unsubscribeConnect(subscriptionId);
+ }
+
+ @Override
+ public boolean isConnected(final PeerAddress peerAddress) {
+ return peerManager.getPeer(peerAddress.getId()).isPresent();
+ }
+
+ @Override
+ public Bytes getPrivateKey() {
+ return Bytes.wrap(privKey.raw());
+ }
+
+ @Override
+ public Optional getPeer(final NodeId id) {
+ return peerManager.getPeer(id);
+ }
+
+ @Override
+ public Stream streamPeers() {
+ return peerManager.streamPeers();
+ }
+
+ @Override
+ public NodeId parseNodeId(final String nodeId) {
+ return new LibP2PNodeId(PeerId.fromBase58(nodeId));
+ }
+
+ @Override
+ public int getPeerCount() {
+ return peerManager.getPeerCount();
+ }
+
+ @Override
+ public int getListenPort() {
+ return listenPort;
+ }
+
+ @Override
+ public SafeFuture stop() {
+ if (!state.compareAndSet(State.RUNNING, State.STOPPED)) {
+ return SafeFuture.COMPLETE;
+ }
+ LOG.debug("JvmLibP2PNetwork.stop()");
+ return SafeFuture.of(host.stop());
+ }
+
+ @Override
+ public NodeId getNodeId() {
+ return nodeId;
+ }
+
+ @Override
+ public Optional getEnr() {
+ return Optional.empty();
+ }
+
+ @Override
+ public Optional getDiscoveryAddress() {
+ return Optional.empty();
+ }
+
+ @Override
+ public SafeFuture gossip(final String topic, final Bytes data) {
+ return gossipNetwork.gossip(topic, data);
+ }
+
+ @Override
+ public TopicChannel subscribe(final String topic, final TopicHandler topicHandler) {
+ return gossipNetwork.subscribe(topic, topicHandler);
+ }
+
+ @Override
+ public Map> getSubscribersByTopic() {
+ return gossipNetwork.getSubscribersByTopic();
+ }
+
+ @Override
+ public void updateGossipTopicScoring(final GossipTopicsScoringConfig config) {
+ gossipNetwork.updateGossipTopicScoring(config);
+ }
+
+ @FunctionalInterface
+ public interface PrivateKeyProvider {
+ PrivKey get();
+ }
+}
diff --git a/src/org/minima/system/network/base/LibP2PParamsFactory.java b/src/org/minima/system/network/base/LibP2PParamsFactory.java
new file mode 100644
index 000000000..1fe0cfbe7
--- /dev/null
+++ b/src/org/minima/system/network/base/LibP2PParamsFactory.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2021 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import io.libp2p.core.PeerId;
+import io.libp2p.pubsub.gossip.GossipParams;
+import io.libp2p.pubsub.gossip.GossipPeerScoreParams;
+import io.libp2p.pubsub.gossip.GossipScoreParams;
+import io.libp2p.pubsub.gossip.GossipTopicScoreParams;
+import io.libp2p.pubsub.gossip.GossipTopicsScoreParams;
+import io.libp2p.pubsub.gossip.builders.GossipPeerScoreParamsBuilder;
+import java.util.Map;
+import java.util.stream.Collectors;
+import kotlin.jvm.functions.Function1;
+import org.minima.system.network.base.gossip.config.GossipConfig;
+import org.minima.system.network.base.gossip.config.GossipPeerScoringConfig;
+import org.minima.system.network.base.gossip.config.GossipScoringConfig;
+import org.minima.system.network.base.gossip.config.GossipTopicScoringConfig;
+import org.minima.system.network.base.peer.LibP2PNodeId;
+import org.minima.system.network.base.gossip.config.GossipTopicScoringConfig;
+
+// import tech.pegasys.teku.networking.p2p.gossip.config.GossipConfig;
+// import tech.pegasys.teku.networking.p2p.gossip.config.GossipPeerScoringConfig;
+// import tech.pegasys.teku.networking.p2p.gossip.config.GossipScoringConfig;
+// import tech.pegasys.teku.networking.p2p.gossip.config.GossipTopicScoringConfig;
+//import tech.pegasys.teku.networking.p2p.libp2p.LibP2PNodeId;
+
+public class LibP2PParamsFactory {
+ public static GossipParams createGossipParams(final GossipConfig gossipConfig) {
+ return GossipParams.builder()
+ .D(gossipConfig.getD())
+ .DLow(gossipConfig.getDLow())
+ .DHigh(gossipConfig.getDHigh())
+ .DLazy(gossipConfig.getDLazy())
+ // Calculate dScore and dOut based on other params
+ .DScore(gossipConfig.getD() * 2 / 3)
+ .DOut(Math.min(gossipConfig.getD() / 2, Math.max(0, gossipConfig.getDLow()) - 1))
+ .fanoutTTL(gossipConfig.getFanoutTTL())
+ .gossipSize(gossipConfig.getAdvertise())
+ .gossipHistoryLength(gossipConfig.getHistory())
+ .heartbeatInterval(gossipConfig.getHeartbeatInterval())
+ .floodPublish(true)
+ .seenTTL(gossipConfig.getSeenTTL())
+ .maxPublishedMessages(1000)
+ .maxTopicsPerPublishedMessage(1)
+ .maxSubscriptions(200)
+ .maxGraftMessages(200)
+ .maxPruneMessages(200)
+ .maxPeersPerPruneMessage(1000)
+ .maxIHaveLength(5000)
+ .maxIWantMessageIds(5000)
+ .build();
+ }
+
+ public static GossipScoreParams createGossipScoreParams(final GossipScoringConfig config) {
+ return GossipScoreParams.builder()
+ .peerScoreParams(createPeerScoreParams(config.getPeerScoringConfig()))
+ .topicsScoreParams(createTopicsScoreParams(config))
+ .gossipThreshold(config.getGossipThreshold())
+ .publishThreshold(config.getPublishThreshold())
+ .graylistThreshold(config.getGraylistThreshold())
+ .acceptPXThreshold(config.getAcceptPXThreshold())
+ .opportunisticGraftThreshold(config.getOpportunisticGraftThreshold())
+ .build();
+ }
+
+ public static GossipPeerScoreParams createPeerScoreParams(final GossipPeerScoringConfig config) {
+ final GossipPeerScoreParamsBuilder builder =
+ GossipPeerScoreParams.builder()
+ .topicScoreCap(config.getTopicScoreCap())
+ .appSpecificWeight(config.getAppSpecificWeight())
+ .ipColocationFactorWeight(config.getIpColocationFactorWeight())
+ .ipColocationFactorThreshold(config.getIpColocationFactorThreshold())
+ .behaviourPenaltyWeight(config.getBehaviourPenaltyWeight())
+ .behaviourPenaltyDecay(config.getBehaviourPenaltyDecay())
+ .behaviourPenaltyThreshold(config.getBehaviourPenaltyThreshold())
+ .decayInterval(config.getDecayInterval())
+ .decayToZero(config.getDecayToZero())
+ .retainScore(config.getRetainScore());
+
+ // Configure optional params
+ config
+ .getAppSpecificScorer()
+ .ifPresent(
+ scorer -> {
+ final Function1 appSpecificScore =
+ peerId -> scorer.scorePeer(new LibP2PNodeId(peerId));
+ builder.appSpecificScore(appSpecificScore);
+ });
+
+ config
+ .getDirectPeerManager()
+ .ifPresent(
+ mgr -> {
+ final Function1 isDirectPeer =
+ peerId -> mgr.isDirectPeer(new LibP2PNodeId(peerId));
+ builder.isDirect(isDirectPeer);
+ });
+
+ config
+ .getWhitelistManager()
+ .ifPresent(
+ mgr -> {
+ // Ip whitelisting
+ final Function1 isIpWhitelisted = mgr::isWhitelisted;
+ builder.ipWhitelisted(isIpWhitelisted);
+ });
+
+ return builder.build();
+ }
+
+ public static GossipTopicsScoreParams createTopicsScoreParams(final GossipScoringConfig config) {
+ final GossipTopicScoreParams defaultTopicParams =
+ createTopicScoreParams(config.getDefaultTopicScoringConfig());
+ final Map topicParams =
+ config.getTopicScoringConfig().entrySet().stream()
+ .collect(
+ Collectors.toMap(Map.Entry::getKey, e -> createTopicScoreParams(e.getValue())));
+ return new GossipTopicsScoreParams(defaultTopicParams, topicParams);
+ }
+
+ public static GossipTopicScoreParams createTopicScoreParams(
+ final GossipTopicScoringConfig config) {
+ return GossipTopicScoreParams.builder()
+ .topicWeight(config.getTopicWeight())
+ .timeInMeshWeight(config.getTimeInMeshWeight())
+ .timeInMeshQuantum(config.getTimeInMeshQuantum())
+ .timeInMeshCap(config.getTimeInMeshCap())
+ .firstMessageDeliveriesWeight(config.getFirstMessageDeliveriesWeight())
+ .firstMessageDeliveriesDecay(config.getFirstMessageDeliveriesDecay())
+ .firstMessageDeliveriesCap(config.getFirstMessageDeliveriesCap())
+ .meshMessageDeliveriesWeight(config.getMeshMessageDeliveriesWeight())
+ .meshMessageDeliveriesDecay(config.getMeshMessageDeliveriesDecay())
+ .meshMessageDeliveriesThreshold(config.getMeshMessageDeliveriesThreshold())
+ .meshMessageDeliveriesCap(config.getMeshMessageDeliveriesCap())
+ .meshMessageDeliveriesActivation(config.getMeshMessageDeliveriesActivation())
+ .meshMessageDeliveryWindow(config.getMeshMessageDeliveryWindow())
+ .meshFailurePenaltyWeight(config.getMeshFailurePenaltyWeight())
+ .meshFailurePenaltyDecay(config.getMeshFailurePenaltyDecay())
+ .invalidMessageDeliveriesWeight(config.getInvalidMessageDeliveriesWeight())
+ .invalidMessageDeliveriesDecay(config.getInvalidMessageDeliveriesDecay())
+ .build();
+ }
+}
diff --git a/src/org/minima/system/network/base/LimitedMap.java b/src/org/minima/system/network/base/LimitedMap.java
new file mode 100644
index 000000000..d009a3b2e
--- /dev/null
+++ b/src/org/minima/system/network/base/LimitedMap.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import com.google.common.cache.CacheBuilder;
+import java.util.Map;
+
+
+/** Helper that creates a map with a maximum capacity. */
+public final class LimitedMap {
+ private LimitedMap() {}
+
+ /**
+ * Creates a limited map. The returned map is safe for concurrent access and evicts the least
+ * recently used items.
+ *
+ * @param maxSize The maximum number of elements to keep in the map.
+ * @param The key type of the map.
+ * @param The value type of the map.
+ * @return A map that will evict elements when the max size is exceeded.
+ */
+ public static Map create(final int maxSize) {
+ return defaultBuilder(maxSize).build().asMap();
+ }
+
+ /**
+ * Creates a limited map using soft references for values. The returned map is safe for concurrent
+ * access and evicts the least recently used items.
+ *
+ * Items may be evicted before maxSize is reached if the garbage collector needs to free up
+ * memory.
+ *
+ * @param maxSize The maximum number of elements to keep in the map.
+ * @param The key type of the map.
+ * @param The value type of the map.
+ * @return A map that will evict elements when the max size is exceeded or when the GC evicts
+ * them.
+ */
+ public static Map createSoft(final int maxSize) {
+ return defaultBuilder(maxSize).softValues().build().asMap();
+ }
+
+ private static CacheBuilder defaultBuilder(final int maxSize) {
+ return CacheBuilder.newBuilder().maximumSize(maxSize);
+ }
+}
+
+
diff --git a/src/org/minima/system/network/base/LimitedSet.java b/src/org/minima/system/network/base/LimitedSet.java
new file mode 100644
index 000000000..fba78c09d
--- /dev/null
+++ b/src/org/minima/system/network/base/LimitedSet.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2019 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import java.util.Collections;
+import java.util.Set;
+
+/** Helper that creates a set with a maximum capacity. */
+public final class LimitedSet {
+
+ private LimitedSet() {}
+
+ /**
+ * Creates a limited set. The returned set is safe for concurrent access and evicts the least
+ * recently used items.
+ *
+ * @param maxSize The maximum number of elements to keep in the set.
+ * @param The type of object held in the set.
+ * @return A set that will evict elements when the max size is exceeded.
+ */
+ public static Set create(final int maxSize) {
+ return Collections.newSetFromMap(LimitedMap.create(maxSize));
+ }
+}
+
diff --git a/src/org/minima/system/network/base/MemKeyValueStore.java b/src/org/minima/system/network/base/MemKeyValueStore.java
new file mode 100644
index 000000000..8eb21af27
--- /dev/null
+++ b/src/org/minima/system/network/base/MemKeyValueStore.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import org.jetbrains.annotations.NotNull;
+
+/** Simple {@link java.util.HashMap} backed {@link KeyValueStore} implementation */
+public class MemKeyValueStore implements KeyValueStore {
+
+ private final Map store = new ConcurrentHashMap<>();
+
+ @Override
+ public void put(@NotNull K key, @NotNull V value) {
+ store.put(key, value);
+ }
+
+ @Override
+ public void remove(@NotNull K key) {
+ store.remove(key);
+ }
+
+ @Override
+ public Optional get(@NotNull K key) {
+ return Optional.ofNullable(store.get(key));
+ }
+}
diff --git a/src/org/minima/system/network/base/MinimaClient.java b/src/org/minima/system/network/base/MinimaClient.java
index 4862e5194..cb8a61f46 100644
--- a/src/org/minima/system/network/base/MinimaClient.java
+++ b/src/org/minima/system/network/base/MinimaClient.java
@@ -71,9 +71,14 @@ public class MinimaClient extends MessageProcessor {
//The UID
String mUID;
+ // NodeID
+ private String nodeID; // this should never change
+ private String nodeRecord; // this is updated when node IP changes
+
//The Host and Port
String mHost;
int mPort;
+ int mLocalPort;
//Ping each other to know you are still up and running.. every 10 mins..
public static final int PING_INTERVAL = 1000 * 60 * 10;
@@ -84,7 +89,26 @@ public class MinimaClient extends MessageProcessor {
*/
boolean mReconnect = false;
int mReconnectAttempts = 0;
+
+ /**
+ * Incoming or Outgoing
+ */
+ boolean mIncoming;
+ /**
+ * Constructor
+ *
+ * @param zSock
+ * @param zNetwork
+ * @throws IOException
+ * @throws UnknownHostException
+ */
+ public MinimaClient(String zHost, int zPort, NetworkHandler zNetwork, String nodeID, String nodeRecord) {
+ this(zHost, zPort, zNetwork);
+ this.nodeID = nodeID;
+ this.nodeRecord = nodeRecord;
+ }
+
/**
* Constructor
*
@@ -99,6 +123,7 @@ public MinimaClient(String zHost, int zPort, NetworkHandler zNetwork) {
//Store
mHost = zHost;
mPort = zPort;
+ mLocalPort = zPort;
//We will attempt to reconnect if this connection breaks..
mReconnect = true;
@@ -109,6 +134,9 @@ public MinimaClient(String zHost, int zPort, NetworkHandler zNetwork) {
//Create a UID
mUID = ""+Math.abs(new Random().nextInt());
+ //Outgoing connection
+ mIncoming = false;
+
//Start the connection
PostMessage(NETCLIENT_INITCONNECT);
}
@@ -118,13 +146,14 @@ public MinimaClient(Socket zSock, NetworkHandler zNetwork) {
//This is an incoming connection.. no reconnect attempt
mReconnect = false;
-
+
//Store
mSocket = zSock;
//Store
mHost = mSocket.getInetAddress().getHostAddress();
mPort = mSocket.getPort();
+ mLocalPort = mSocket.getLocalPort();
//Main network Handler
mNetworkMain = zNetwork;
@@ -132,6 +161,9 @@ public MinimaClient(Socket zSock, NetworkHandler zNetwork) {
//Create a UID
mUID = ""+Math.abs(new Random().nextInt());
+ //Incoming connection
+ mIncoming = true;
+
//Start the system..
PostMessage(NETCLIENT_STARTUP);
}
@@ -160,6 +192,22 @@ public String getUID() {
return mUID;
}
+ public boolean isIncoming() {
+ return mIncoming;
+ }
+
+ public int getLocalPort() {
+ return mLocalPort;
+ }
+
+ public String getNodeID() {
+ return nodeID;
+ }
+
+ public String getNodeRecord() {
+ return nodeRecord;
+ }
+
public NetworkHandler getNetworkHandler() {
return mNetworkMain;
}
@@ -170,6 +218,8 @@ public JSONObject toJSON() {
ret.put("uid", mUID);
ret.put("host", getHost());
ret.put("port", getPort());
+ ret.put("localport", getLocalPort());
+ ret.put("incoming", mIncoming);
return ret;
}
diff --git a/src/org/minima/system/network/base/MplexFirewall.java b/src/org/minima/system/network/base/MplexFirewall.java
new file mode 100644
index 000000000..117fc8f12
--- /dev/null
+++ b/src/org/minima/system/network/base/MplexFirewall.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2021 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.libp2p.core.ChannelVisitor;
+import io.libp2p.core.Connection;
+import io.libp2p.etc.util.netty.mux.MuxId;
+import io.libp2p.mux.MuxFrame;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.Supplier;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.NotNull;
+//import tech.pegasys.teku.infrastructure.async.FutureUtil;
+
+public class MplexFirewall implements ChannelVisitor {
+
+ private static final Logger LOG = LogManager.getLogger();
+ private static final long ONE_SECOND = 1000;
+
+ private final int remoteOpenStreamsRateLimit;
+ private final int remoteParallelOpenStreamsLimit;
+ private final Supplier currentTimeSupplier;
+
+ public MplexFirewall(int remoteOpenStreamsRateLimit, int remoteParallelOpenStreamsLimit) {
+ this(remoteOpenStreamsRateLimit, remoteParallelOpenStreamsLimit, System::currentTimeMillis);
+ }
+
+ @VisibleForTesting
+ MplexFirewall(
+ int remoteOpenStreamsRateLimit,
+ int remoteParallelOpenStreamsLimit,
+ Supplier currentTimeSupplier) {
+ this.remoteOpenStreamsRateLimit = remoteOpenStreamsRateLimit;
+ this.remoteParallelOpenStreamsLimit = remoteParallelOpenStreamsLimit;
+ this.currentTimeSupplier = currentTimeSupplier;
+ }
+
+ protected void remoteParallelOpenStreamLimitExceeded(MplexFirewallHandler peerMplexHandler) {
+ LOG.debug("Abruptly closing peer connection due to exceeding parallel open streams limit");
+ FutureUtil.ignoreFuture(peerMplexHandler.getConnection().close());
+ }
+
+ protected void remoteOpenFrameRateLimitExceeded(MplexFirewallHandler peerMplexHandler) {
+ LOG.debug("Abruptly closing peer connection due to exceeding open mplex frame rate limit");
+ FutureUtil.ignoreFuture(peerMplexHandler.getConnection().close());
+ }
+
+ @Override
+ public void visit(@NotNull Connection connection) {
+ MplexFirewallHandler firewallHandler = new MplexFirewallHandler(connection);
+ connection.pushHandler(firewallHandler);
+ }
+
+ private class MplexFirewallHandler extends ChannelDuplexHandler {
+
+ private final Connection connection;
+ private int openFrameCounter = 0;
+ private long startCounterTime = 0;
+ private final Set remoteOpenedStreamIds = new HashSet<>();
+
+ public MplexFirewallHandler(Connection connection) {
+ this.connection = connection;
+ }
+
+ @Override
+ public void channelRead(ChannelHandlerContext ctx, Object msg) {
+ MuxFrame muxFrame = (MuxFrame) msg;
+ boolean blockFrame = false;
+ if (muxFrame.getFlag() == MuxFrame.Flag.OPEN) {
+ remoteOpenedStreamIds.add(muxFrame.getId());
+ if (remoteOpenedStreamIds.size() > remoteParallelOpenStreamsLimit) {
+ remoteParallelOpenStreamLimitExceeded(this);
+ blockFrame = true;
+ }
+
+ long curTime = currentTimeSupplier.get();
+ if (curTime - startCounterTime > ONE_SECOND) {
+ startCounterTime = curTime;
+ openFrameCounter = 0;
+ } else {
+ openFrameCounter++;
+ if (openFrameCounter > remoteOpenStreamsRateLimit) {
+ remoteOpenFrameRateLimitExceeded(this);
+ blockFrame = true;
+ }
+ }
+ } else if (muxFrame.getFlag() == MuxFrame.Flag.CLOSE
+ || muxFrame.getFlag() == MuxFrame.Flag.RESET) {
+ remoteOpenedStreamIds.remove(muxFrame.getId());
+ }
+ if (!blockFrame) {
+ ctx.fireChannelRead(msg);
+ }
+ }
+
+ @Override
+ public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
+ MuxFrame muxFrame = (MuxFrame) msg;
+ if (muxFrame.getFlag() == MuxFrame.Flag.RESET) {
+ // Track only RESET since CLOSE from local doesn't close the stream for writing from remote
+ remoteOpenedStreamIds.remove(muxFrame.getId());
+ }
+ // ignoring since the write() just returns `promise` instance
+ FutureUtil.ignoreFuture(ctx.write(msg, promise));
+ }
+
+ public Connection getConnection() {
+ return connection;
+ }
+ }
+}
diff --git a/src/org/minima/system/network/base/NetworkConfig.java b/src/org/minima/system/network/base/NetworkConfig.java
new file mode 100644
index 000000000..d580bfab5
--- /dev/null
+++ b/src/org/minima/system/network/base/NetworkConfig.java
@@ -0,0 +1,209 @@
+/*
+ * Copyright 2019 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.net.InetAddresses.isInetAddress;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Optional;
+import java.util.OptionalInt;
+import java.util.function.Consumer;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+// import tech.pegasys.teku.infrastructure.io.PortAvailability;
+// import tech.pegasys.teku.networking.p2p.gossip.config.GossipConfig;
+// import tech.pegasys.teku.util.config.InvalidConfigurationException;
+import org.minima.system.network.base.gossip.config.GossipConfig;
+
+public class NetworkConfig {
+ private static final Logger LOG = LogManager.getLogger(NetworkConfig.class);
+
+ private final GossipConfig gossipConfig;
+ private final WireLogsConfig wireLogsConfig;
+
+ private final boolean isEnabled;
+ private final Optional privateKeyFile;
+ private final String networkInterface;
+ private final Optional advertisedIp;
+ private final int listenPort;
+ private final OptionalInt advertisedPort;
+
+ private NetworkConfig(
+ final boolean isEnabled,
+ final GossipConfig gossipConfig,
+ final WireLogsConfig wireLogsConfig,
+ final Optional privateKeyFile,
+ final String networkInterface,
+ final Optional advertisedIp,
+ final int listenPort,
+ final OptionalInt advertisedPort) {
+
+ this.privateKeyFile = privateKeyFile;
+ this.networkInterface = networkInterface;
+
+ this.advertisedIp = advertisedIp.filter(ip -> !ip.isBlank());
+ this.isEnabled = isEnabled;
+ if (this.advertisedIp.map(ip -> !isInetAddress(ip)).orElse(false)) {
+ throw new InvalidConfigurationException(
+ String.format(
+ "Advertised ip (%s) is set incorrectly.", this.advertisedIp.orElse("EMPTY")));
+ }
+
+ this.listenPort = listenPort;
+ this.advertisedPort = advertisedPort;
+ this.gossipConfig = gossipConfig;
+ this.wireLogsConfig = wireLogsConfig;
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ public void validateListenPortAvailable() {
+ if (listenPort != 0 && !PortAvailability.isPortAvailable(listenPort)) {
+ throw new InvalidConfigurationException(
+ String.format(
+ "P2P Port %d (TCP/UDP) is already in use. "
+ + "Check for other processes using this port.",
+ listenPort));
+ }
+ }
+
+ public boolean isEnabled() {
+ return isEnabled;
+ }
+
+ public Optional getPrivateKeyFile() {
+ return privateKeyFile;
+ }
+
+ public String getNetworkInterface() {
+ return networkInterface;
+ }
+
+ public String getAdvertisedIp() {
+ return resolveAnyLocalAddress(advertisedIp.orElse(networkInterface));
+ }
+
+ public boolean hasUserExplicitlySetAdvertisedIp() {
+ return advertisedIp.isPresent();
+ }
+
+ public int getListenPort() {
+ return listenPort;
+ }
+
+ public int getAdvertisedPort() {
+ return advertisedPort.orElse(listenPort);
+ }
+
+ public GossipConfig getGossipConfig() {
+ return gossipConfig;
+ }
+
+ public WireLogsConfig getWireLogsConfig() {
+ return wireLogsConfig;
+ }
+
+ private String resolveAnyLocalAddress(final String ipAddress) {
+ try {
+ final InetAddress advertisedAddress = InetAddress.getByName(ipAddress);
+ if (advertisedAddress.isAnyLocalAddress()) {
+ return InetAddress.getLocalHost().getHostAddress();
+ } else {
+ return ipAddress;
+ }
+ } catch (UnknownHostException err) {
+ LOG.error(
+ "Unable to start LibP2PNetwork due to failed attempt at obtaining host address", err);
+ return ipAddress;
+ }
+ }
+
+ public static class Builder {
+ public static final int DEFAULT_P2P_PORT = 9000;
+
+ private final GossipConfig.Builder gossipConfigBuilder = GossipConfig.builder();
+ private final WireLogsConfig.Builder wireLogsConfig = WireLogsConfig.builder();
+
+ private Boolean isEnabled = true;
+ private Optional privateKeyFile = Optional.empty();
+ private String networkInterface = "0.0.0.0";
+ private Optional advertisedIp = Optional.empty();
+ private Integer listenPort = DEFAULT_P2P_PORT;
+ private OptionalInt advertisedPort = OptionalInt.empty();
+
+ private Builder() {}
+
+ public NetworkConfig build() {
+ return new NetworkConfig(
+ isEnabled,
+ gossipConfigBuilder.build(),
+ wireLogsConfig.build(),
+ privateKeyFile,
+ networkInterface,
+ advertisedIp,
+ listenPort,
+ advertisedPort);
+ }
+
+ public Builder isEnabled(final Boolean enabled) {
+ checkNotNull(enabled);
+ isEnabled = enabled;
+ return this;
+ }
+
+ public Builder gossipConfig(final Consumer consumer) {
+ consumer.accept(gossipConfigBuilder);
+ return this;
+ }
+
+ public Builder wireLogs(final Consumer consumer) {
+ consumer.accept(wireLogsConfig);
+ return this;
+ }
+
+ public Builder privateKeyFile(final String privateKeyFile) {
+ checkNotNull(privateKeyFile);
+ this.privateKeyFile = Optional.of(privateKeyFile).filter(f -> !f.isBlank());
+ return this;
+ }
+
+ public Builder networkInterface(final String networkInterface) {
+ checkNotNull(networkInterface);
+ this.networkInterface = networkInterface;
+ return this;
+ }
+
+ public Builder advertisedIp(final Optional advertisedIp) {
+ checkNotNull(advertisedIp);
+ this.advertisedIp = advertisedIp;
+ return this;
+ }
+
+ public Builder listenPort(final Integer listenPort) {
+ checkNotNull(listenPort);
+ this.listenPort = listenPort;
+ return this;
+ }
+
+ public Builder advertisedPort(final OptionalInt advertisedPort) {
+ checkNotNull(advertisedPort);
+ this.advertisedPort = advertisedPort;
+ return this;
+ }
+ }
+}
diff --git a/src/org/minima/system/network/base/NoOpDiscoveryService.java b/src/org/minima/system/network/base/NoOpDiscoveryService.java
new file mode 100644
index 000000000..e53779867
--- /dev/null
+++ b/src/org/minima/system/network/base/NoOpDiscoveryService.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+import org.apache.tuweni.bytes.Bytes;
+// import tech.pegasys.teku.infrastructure.async.SafeFuture;
+// import tech.pegasys.teku.networking.p2p.discovery.DiscoveryPeer;
+// import tech.pegasys.teku.networking.p2p.discovery.DiscoveryService;
+import org.minima.system.network.base.peer.DiscoveryPeer;
+
+public class NoOpDiscoveryService implements DiscoveryService {
+
+ @Override
+ public SafeFuture start() {
+ return SafeFuture.COMPLETE;
+ }
+
+ @Override
+ public SafeFuture stop() {
+ return SafeFuture.COMPLETE;
+ }
+
+ @Override
+ public Stream streamKnownPeers() {
+ return Stream.empty();
+ }
+
+ @Override
+ public SafeFuture searchForPeers() {
+ return SafeFuture.COMPLETE;
+ }
+
+ @Override
+ public Optional getEnr() {
+ return Optional.empty();
+ }
+
+ @Override
+ public Optional getDiscoveryAddress() {
+ return Optional.empty();
+ }
+
+ @Override
+ public void updateCustomENRField(String fieldName, Bytes value) {}
+}
diff --git a/src/org/minima/system/network/base/NodeRecordConverter.java b/src/org/minima/system/network/base/NodeRecordConverter.java
new file mode 100644
index 000000000..2a55f619e
--- /dev/null
+++ b/src/org/minima/system/network/base/NodeRecordConverter.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import static org.minima.system.network.base.DiscoveryNetwork.ATTESTATION_SUBNET_ENR_FIELD;
+import static org.minima.system.network.base.DiscoveryNetwork.ETH2_ENR_FIELD;
+
+import java.net.InetSocketAddress;
+import java.util.Optional;
+import java.util.function.Function;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.tuweni.bytes.Bytes;
+import org.ethereum.beacon.discovery.schema.EnrField;
+import org.ethereum.beacon.discovery.schema.NodeRecord;
+import org.minima.system.network.base.peer.DiscoveryPeer;
+//import org.minima.system.network.base.EnrForkId;
+import org.minima.system.network.base.ssz.SszBitvector;
+
+public class NodeRecordConverter {
+ private static final Logger LOG = LogManager.getLogger(NodeRecordConverter.class);
+
+ static Optional convertToDiscoveryPeer(final NodeRecord nodeRecord) {
+ return nodeRecord
+ .getTcpAddress()
+ .map(address -> socketAddressToDiscoveryPeer(nodeRecord, address));
+ }
+
+ private static DiscoveryPeer socketAddressToDiscoveryPeer(
+ final NodeRecord nodeRecord, final InetSocketAddress address) {
+
+ final Optional enrForkId =
+ parseField(nodeRecord, ETH2_ENR_FIELD, EnrForkId.SSZ_SCHEMA::sszDeserialize);
+
+ final SszBitvector persistentSubnets =
+ parseField(
+ nodeRecord,
+ ATTESTATION_SUBNET_ENR_FIELD,
+ DiscV5Service.SUBNET_SUBSCRIPTIONS_SCHEMA::fromBytes)
+ .orElse(DiscV5Service.SUBNET_SUBSCRIPTIONS_SCHEMA.getDefault());
+
+
+ Bytes nodeId = nodeRecord.getNodeId();
+ String enr = nodeRecord.asEnr();
+ return new DiscoveryPeer(
+ ((Bytes) nodeRecord.get(EnrField.PKEY_SECP256K1)), address, enrForkId, persistentSubnets, nodeId, enr);
+ }
+
+ private static Optional parseField(
+ final NodeRecord nodeRecord, final String fieldName, final Function parse) {
+ try {
+ return Optional.ofNullable((Bytes) nodeRecord.get(fieldName)).map(parse);
+ } catch (final Exception e) {
+ LOG.debug("Failed to parse ENR field {}", fieldName, e);
+ return Optional.empty();
+ }
+ }
+}
diff --git a/src/org/minima/system/network/base/P2PMinimaDiscovery.java b/src/org/minima/system/network/base/P2PMinimaDiscovery.java
new file mode 100644
index 000000000..76bdb9d26
--- /dev/null
+++ b/src/org/minima/system/network/base/P2PMinimaDiscovery.java
@@ -0,0 +1,7 @@
+package org.minima.system.network.base;
+
+public class P2PMinimaDiscovery extends P2PMinimaDiscoveryBinding {
+ public P2PMinimaDiscovery() {
+ super(new P2PMinimaDiscoveryProtocol());
+ }
+}
diff --git a/src/org/minima/system/network/base/P2PMinimaDiscoveryBinding.java b/src/org/minima/system/network/base/P2PMinimaDiscoveryBinding.java
new file mode 100644
index 000000000..7b64f1883
--- /dev/null
+++ b/src/org/minima/system/network/base/P2PMinimaDiscoveryBinding.java
@@ -0,0 +1,9 @@
+package org.minima.system.network.base;
+
+import io.libp2p.core.multistream.StrictProtocolBinding;
+
+public class P2PMinimaDiscoveryBinding extends StrictProtocolBinding {
+ public P2PMinimaDiscoveryBinding(P2PMinimaDiscoveryProtocol mdp) {
+ super("/p2p/minima/1.0.0", mdp);
+ }
+}
\ No newline at end of file
diff --git a/src/org/minima/system/network/base/P2PMinimaDiscoveryProtocol.java b/src/org/minima/system/network/base/P2PMinimaDiscoveryProtocol.java
new file mode 100644
index 000000000..7ad3da60e
--- /dev/null
+++ b/src/org/minima/system/network/base/P2PMinimaDiscoveryProtocol.java
@@ -0,0 +1,118 @@
+package org.minima.system.network.base;
+
+
+import io.libp2p.core.PeerId;
+import io.libp2p.core.Stream;
+//import io.libp2p.etc.types.toByteBuf;
+import io.libp2p.protocol.ProtocolHandler;
+import io.libp2p.protocol.ProtocolMessageHandler;
+import io.netty.buffer.ByteBuf;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.util.concurrent.CompletableFuture;
+
+interface P2PMinimaDiscoveryProtocolController {
+ //fun send(message: String)
+ public void send(String message);
+}
+
+// class Ping : PingBinding(PingProtocol())
+
+// open class PingBinding(ping: PingProtocol) :
+// StrictProtocolBinding("/ipfs/ping/1.0.0", ping)
+
+public class P2PMinimaDiscoveryProtocol extends ProtocolHandler {
+
+ public P2PMinimaDiscoveryProtocol() {
+ super(Long.MAX_VALUE, Long.MAX_VALUE);
+ //TODO Auto-generated constructor stub
+ }
+
+ private CompletableFuture onStart(Stream stream) {
+ // TODO: add a handler and do something
+ CompletableFuture ready = new CompletableFuture();
+ // val handler = MDPHandler(chatCallback, ready)
+ //stream.pushHandler(handler)
+ //return ready.thenApply { handler }
+ return ready;
+ }
+
+ protected CompletableFuture onStartInitiator(Stream stream) {
+ return onStart(stream);
+ }
+
+ protected CompletableFuture onStartResponder(Stream stream) {
+ return onStart(stream);
+ }
+
+ class MDPHandler implements ProtocolMessageHandler, P2PMinimaDiscoveryProtocolController {
+
+ private Stream stream;
+ // private mdpCallback;
+
+ public MDPHandler() {
+ //todo: add OnChatMessage and ready equivalents in constructor and save as private fields
+ }
+
+ @Override
+ public void onActivated(Stream stream) {
+ this.stream = stream;
+ //ready.complete(null);
+ }
+
+ @Override
+ public void send(String message) {
+ byte[] data = message.getBytes(Charset.defaultCharset());
+ stream.writeAndFlush(data); // does this need to be in a ByteBuffer
+ }
+
+ @Override
+ public void fireMessage(Stream arg0, Object arg1) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void onClosed(Stream arg0) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void onException(Throwable arg0) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void onMessage(Stream stream, ByteBuf msg) {
+ String msgStr = msg.toString(Charset.defaultCharset());
+ System.out.println("Received message: " + msgStr);
+ //mdpCallback(stream.remotePeerId(), msgStr);
+ }
+ }
+
+// open inner class Chatter(
+// private val chatCallback: OnChatMessage,
+// val ready: CompletableFuture
+// ) : ProtocolMessageHandler, ChatController {
+// lateinit var stream: Stream
+
+// override fun onActivated(stream: Stream) {
+// this.stream = stream
+// ready.complete(null)
+// }
+
+// override fun onMessage(stream: Stream, msg: ByteBuf) {
+// val msgStr = msg.toString(Charset.defaultCharset())
+// chatCallback(stream.remotePeerId(), msgStr)
+// }
+
+// override fun send(message: String) {
+// val data = message.toByteArray(Charset.defaultCharset())
+// stream.writeAndFlush(data.toByteBuf())
+// }
+// }
+
+}
diff --git a/src/org/minima/system/network/base/P2PNetwork.java b/src/org/minima/system/network/base/P2PNetwork.java
new file mode 100644
index 000000000..7c70519ba
--- /dev/null
+++ b/src/org/minima/system/network/base/P2PNetwork.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2019 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+// import org.apache.tuweni.bytes.Bytes;
+// import tech.pegasys.teku.infrastructure.async.SafeFuture;
+// import tech.pegasys.teku.networking.p2p.discovery.DiscoveryPeer;
+// import tech.pegasys.teku.networking.p2p.gossip.GossipNetwork;
+// import tech.pegasys.teku.networking.p2p.peer.NodeId;
+// import tech.pegasys.teku.networking.p2p.peer.Peer;
+// import tech.pegasys.teku.networking.p2p.peer.PeerConnectedSubscriber;
+
+import org.apache.tuweni.bytes.Bytes;
+import org.minima.system.network.base.gossip.GossipNetwork;
+import org.minima.system.network.base.peer.DiscoveryPeer;
+import org.minima.system.network.base.peer.NodeId;
+import org.minima.system.network.base.peer.Peer;
+import org.minima.system.network.base.peer.PeerAddress;
+import org.minima.system.network.base.peer.PeerConnectedSubscriber;
+
+public interface P2PNetwork extends GossipNetwork {
+
+ enum State {
+ IDLE,
+ RUNNING,
+ STOPPED
+ }
+
+ /**
+ * Connects to a Peer using a user supplied address. The address format is specific to the network
+ * implementation. If a connection already exists for this peer, the future completes with the
+ * existing peer.
+ *
+ * The {@link PeerAddress} must have been created using the {@link #createPeerAddress(String)}
+ * method of this same implementation.
+ *
+ * @param peer Peer to connect to.
+ * @return A future which completes when the connection is established, containing the newly
+ * connected peer.
+ */
+ SafeFuture connect(PeerAddress peer);
+
+ /**
+ * Parses a peer address in any of this network's supported formats.
+ *
+ * @param peerAddress the address to parse
+ * @return a {@link PeerAddress} which is supported by {@link #connect(PeerAddress)} for
+ * initiating connections
+ */
+ PeerAddress createPeerAddress(String peerAddress);
+
+ /**
+ * Converts a {@link DiscoveryPeer} to a {@link PeerAddress} which can be used with this network's
+ * {@link #connect(PeerAddress)} method.
+ *
+ * @param discoveryPeer the discovery peer to convert
+ * @return a {@link PeerAddress} which is supported by {@link #connect(PeerAddress)} for
+ * initiating connections
+ */
+ PeerAddress createPeerAddress(DiscoveryPeer discoveryPeer);
+
+ long subscribeConnect(PeerConnectedSubscriber subscriber);
+
+ void unsubscribeConnect(long subscriptionId);
+
+ boolean isConnected(PeerAddress peerAddress);
+
+ Bytes getPrivateKey();
+
+ Optional getPeer(NodeId id);
+
+ Stream streamPeers();
+
+ NodeId parseNodeId(final String nodeId);
+
+ int getPeerCount();
+
+ String getNodeAddress();
+
+ NodeId getNodeId();
+
+ int getListenPort();
+
+ /**
+ * Get the Ethereum Node Record (ENR) for the local node, if one exists.
+ *
+ * @return the local ENR.
+ */
+ Optional getEnr();
+
+ Optional getDiscoveryAddress();
+
+ /**
+ * Starts the P2P network layer.
+ *
+ * @return
+ */
+ SafeFuture start();
+
+ /** Stops the P2P network layer. */
+ SafeFuture stop();
+}
diff --git a/src/org/minima/system/network/base/P2PStart.java b/src/org/minima/system/network/base/P2PStart.java
new file mode 100644
index 000000000..0f8e2737e
--- /dev/null
+++ b/src/org/minima/system/network/base/P2PStart.java
@@ -0,0 +1,546 @@
+package org.minima.system.network.base;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.Vector;
+import java.util.concurrent.ExecutionException;
+import java.util.function.BiConsumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static io.netty.buffer.Unpooled.*;
+
+// Import log4j classes.
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+import org.minima.system.network.NetworkHandler;
+import org.minima.system.network.base.DiscoveryNetworkFactory.DiscoveryNetworkBuilder;
+import org.minima.system.network.base.LibP2PNetwork.PrivateKeyProvider;
+import org.minima.system.network.base.libp2p.PrivateKeyGenerator;
+//import org.minima.system.network.base.NodeRecordConverter;
+import org.minima.system.network.base.peer.DiscoveryPeer;
+import org.minima.system.network.base.peer.LibP2PNodeId;
+import org.minima.system.network.base.peer.NodeId;
+import org.minima.system.network.base.peer.Peer;
+import org.minima.utils.messages.Message;
+import org.minima.utils.messages.MessageProcessor;
+import org.minima.utils.messages.TimerMessage;
+
+//import org.ethereum.beacon.discovery.schema.NodeRecord;
+import org.ethereum.beacon.discovery.schema.NodeRecord;
+import org.ethereum.beacon.discovery.schema.NodeRecordFactory;
+
+import io.libp2p.core.PeerId;
+import io.libp2p.core.crypto.PrivKey;
+import io.libp2p.core.crypto.PubKey;
+import io.libp2p.core.multiformats.Multihash;
+import io.libp2p.crypto.keys.Secp256k1Kt;
+import io.libp2p.etc.encode.Base58;
+import io.netty.buffer.ByteBuf;
+import io.libp2p.core.crypto.KEY_TYPE;
+import io.libp2p.core.crypto.KeyKt;
+//import io.libp2p.core.crypto.marshalPublicKey;
+
+public class P2PStart extends MessageProcessor {
+
+ private static final Logger logger = LogManager.getLogger(P2PStart.class);
+ public static final String P2P_THREAD = "P2P";
+ // these messages only control LIBP2P+DISCV5 <> Minima comms at the moment
+ public static final String P2P_START_SCAN = "P2P_START_SCAN";
+ public static final String P2P_STOP_SCAN = "P2P_STOP_SCAN";
+ public static final String P2P_SAVE_NEIGHBOURS = "P2P_SAVE_NEIGHBOURS";
+ public static final int P2P_SCAN_INTERVAL = 10*1000; // sync neighbours table from p2p layer every N ms.
+ public static final int SAVE_NEIGHBOURS_DELAY = 10*1000; // save list every 10 seconds
+ public static final String COMMA_DELIMITER = ",";
+ private String mConfFolder;
+ private NetworkHandler mNetwork;
+ private DiscoveryNetwork network;
+ Set activeKnownNodes;
+ Hashtable allDiscoveredNodes2 = new Hashtable<>();
+ private NodeId nodeId;
+ private PubKey pubKey;
+ private File mP2PBootnodesFile;
+ private File mRoot;
+
+ class MinimaNodeInfo {
+ final public InetSocketAddress socket;
+ final public String nodeRecord;
+ final public String nodeID;
+ final public String discoMultiAddrTCP;
+ public MinimaNodeInfo(String nodeID, String nodeRecord, InetSocketAddress socket, String discoMultiAddrTCP) {
+ this.nodeID = nodeID;
+ this.nodeRecord = nodeRecord;
+ this.socket = socket;
+ this.discoMultiAddrTCP = discoMultiAddrTCP;
+ }
+ }
+
+ // staticPeers = list of static peers in multiaddr format: /ip4/127.0.0.1/tcp/10219/p2p/16Uiu2HAmCnuHVjxoQtZzqenqjRr6hAja1XWCuC1SiqcWcWcp4iSt
+ // bootnodes = list of ENR: enr:-Iu4QGvbP4hn3cxao3aFyZfeGBG0Ygp-KPJsK9h7pM_0FfCGauk0P2haW7AEiLaMLEDxRngy4SjCx6GGfwlsRBf0BBwBgmlkgnY0gmlwhH8AAAGJc2VjcDI1NmsxoQMCButDl63KBqEEyxV2R3nCvnHb7sEIgOACbb6yt6oxqYN0Y3CCJ-uDdWRwgifr
+ // ENR above in enr-viewer.com leads to: pubkey=0x030206eb4397adca06a104cb15764779c2be71dbeec10880e0026dbeb2b7aa31a9
+ // ip=127.0.0.1, tcp=10219, udp=10219
+ // if we protobuf the pubkey (crypto.proto) we get 08021221030206eb4397adca06a104cb15764779c2be71dbeec10880e0026dbeb2b7aa31a9
+ // 08 means varint follows with value 02. which means SECP256K1 key
+ // 12 means String follows, starting with length. length is 0x21 or 33 dec
+ // now we multihash it. Because the key is small (<50) it is inlined: 002508021221030206eb4397adca06a104cb15764779c2be71dbeec10880e0026dbeb2b7aa31a9
+ // 00 -> Identity, 0x25=length (protobuf pubkey SECP256K1, 0x21+0x04)
+ // and now we base58 encode it: 16Uiu2HAmCnuHVjxoQtZzqenqjRr6hAja1XWCuC1SiqcWcWcp4iSt
+ // So the hex prefix to the pubkey to build the peerid is always 002508021221 (in our use case).
+ public P2PStart(String zConfFolder, NetworkHandler minimaNet, String[] _staticPeers, String[] _bootnodes) {
+ super(P2P_THREAD);
+ this.mConfFolder = zConfFolder;
+ mNetwork = minimaNet;
+ Vector staticPeers = new Vector<>();
+ Vector bootnodes = new Vector<>();
+ if(_staticPeers == null || _staticPeers.length == 0) {
+ logger.info("P2P layer - no static peer provided by minima.");
+ }
+ if(_bootnodes == null || _bootnodes.length == 0) {
+ logger.info("P2P layer - no bootnode provided by minima.");
+ }
+ if(_staticPeers != null && _bootnodes != null && _staticPeers.length == _bootnodes.length) {
+ logger.info("P2P layer - received bootnode and staticpeer info from minima, adding to config");
+ Collections.addAll(staticPeers, _staticPeers);
+ Collections.addAll(bootnodes, _bootnodes);
+ }
+
+ // check config file for SECP256K1 private key
+ mRoot = ensureFolder(new File(mConfFolder));
+ String mRootPath = mRoot.getAbsolutePath();
+
+ //Current used TxPOW
+ File mP2PDir = ensureFolder(new File(mRoot,"p2p"));
+ File mP2PNodePrivKeyFile = new File(mP2PDir, "NodePrivKey.pkey");
+ mP2PBootnodesFile = new File(mP2PDir, "bootnodes.csv");
+
+ // two lines below just to get rid of temporary not initialized issue
+ PrivateKeyProvider provider = PrivateKeyGenerator::generate;
+ PrivKey privKey = provider.get();
+ privKey = loadNodePrivateKey(mP2PNodePrivKeyFile);
+ if(privKey == null) {
+ privKey = generateNodePrivateKey(mP2PNodePrivKeyFile);
+ }
+
+ if(privKey == null) {
+ System.out.println("P2P Error - priv key uninitialized!");
+ logger.error("P2P Error - priv key uninitialized!");
+ return;
+ }
+
+ PeerId pid = PeerId.fromPubKey(privKey.publicKey());
+ nodeId = new LibP2PNodeId(pid);
+ pubKey = privKey.publicKey();
+
+ //byte[] marshaledPubKey = KeyKt.marshalPublicKey(privKey.publicKey());
+ // if pubkey is less than 42 bytes then peerid will be
+ // the multihash digest of identity (0) and the pubkey as a protobuf (keytype, data)
+ // logger.debug("P2P layer - peerid - raw hex: " + pid.toHex());
+ // logger.debug("P2P layer - pubkey - raw hex: " + hex(privKey.publicKey().bytes()));
+ // logger.debug("P2P layer - protobuf pubkey: " + P2PStart.hex(marshaledPubKey));
+ // logger.debug("P2P layer - protobuf pubkey length (dec): " + marshaledPubKey.length);
+ // logger.debug("P2P layer - protobuf pubkey length (hex)): " + Integer.toHexString(marshaledPubKey.length));
+ //ByteBuf wrappedBuf = wrappedBuffer(marshaledPubKey);
+ // logger.debug("P2P layer - wrapped buff protobuf pubkey (hex)): " + hex(wrappedBuf.array())); // Integer.toHexString(marshaledPubKey.length));
+ // logger.debug("P2P layer - wrapped buff protobuf pubkey capacity (dec): " + wrappedBuf.capacity());
+ // The line below does not work. It should just add 0x0025 in front of the protobuf (identity+protobuf pubkey length).
+ //Multihash mhash = Multihash.digest(new Multihash.Descriptor(Multihash.Digest.Identity, null), wrappedBuf, (marshaledPubKey.length)*8);
+ //System.out.println("P2P layer - multihash Str value: " + mhash.toString());
+ // last 8 bytes are zeros for some reason
+ // as we are fixed size we only copy the meaningful bytes before Base58 encoding.
+ //byte[] mhashbytes = mhash.getBytes().copy(0, 39).array();
+ //logger.debug("P2P layer - multihash hex bytes value: " + hex(mhashbytes));
+ //logger.debug("P2P layer - multihash base58 value: " + Base58.INSTANCE.encode(mhashbytes)); // same as nodeId.toBase58()
+ //logger.debug("P2P layer - peerid - base58 encoded: " + pid.toHex());
+ //logger.debug("P2P layer - nodeid (peerid base58): " + nodeId.toString()); // same as .toBase58()
+ logger.debug("P2P layer - nodeid base58: " + nodeId.toBase58());
+
+ // bootnodes CSV
+ List> records = loadP2PNeighbours(mP2PBootnodesFile);
+ if (records != null) {
+ for (List record : records) {
+ staticPeers.add(record.get(1));
+ bootnodes.add(record.get(2));
+ }
+ }
+
+ DiscoveryNetworkFactory factory = new DiscoveryNetworkFactory();
+ try {
+ if(staticPeers != null && staticPeers.size() > 0 && bootnodes != null && bootnodes.size() > 0) {
+ System.out.println("Building p2p layer using provided params: staticpeer=" + staticPeers.get(0) + " and bootnode=" + bootnodes.get(0));
+ DiscoveryNetworkBuilder builder = factory.builder();
+ builder = builder.setPrivKey(privKey);
+ for(int i = 0; i < staticPeers.size(); i++) {
+ builder = builder.staticPeer(staticPeers.get(i)).bootnode(bootnodes.get(i));
+ }
+ network = builder.buildAndStart(mNetwork.getBasePort() + 5);
+ } else if(staticPeers == null || staticPeers.size() == 0) {
+ logger.info("P2P: starting in standalone mode");
+ System.out.println("P2P: starting in standalone mode");
+ network = factory.builder().setPrivKey(privKey).buildAndStart(mNetwork.getBasePort() + 5);
+ }
+ } catch (Exception e) {
+ logger.error("P2P failed to start through DiscoveyrNetworkFactory.");
+ e.printStackTrace();
+ }
+
+ if(network != null) {
+ // P2P initialization complete
+ Optional discAddr = network.getDiscoveryAddress();
+ logger.warn("LOGGER nodeid: " + network.getNodeId() + " , nodeAddress: " + network.getNodeAddress()
+ + " , discovery address: " + discAddr.get());
+ System.out.println("P2P nodeid: " + network.getNodeId() + " , nodeAddress: " + network.getNodeAddress()
+ + " , discovery address: " + discAddr.get());
+ System.out.println("Starting discovery loop info");
+ activeKnownNodes = new HashSet<>();
+ PostTimerMessage(new TimerMessage(P2P_SCAN_INTERVAL, P2P_START_SCAN)); // could also be a TimerMessage
+ // PostMessage(P2P_SAVE_NEIGHBOURS); // for now we save neighbours at the end of each scan, this timer is not used
+ // PostTimerMessage(new TimerMessage(SAVE_NEIGHBOURS_DELAY, P2P_SAVE_NEIGHBOURS));
+ } else {
+ // initialization failed - what do we do?
+ logger.error("Failed to start P2P network.");
+ }
+ }
+
+ public static String hex(byte[] bytes) {
+ StringBuilder result = new StringBuilder();
+ for (byte aByte : bytes) {
+ result.append(String.format("%02x", aByte));
+ // upper case
+ // result.append(String.format("%02X", aByte));
+ }
+ return result.toString();
+ }
+
+ public String convertToCSV(String pubKey, MinimaNodeInfo i) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(pubKey);
+ builder.append(",");
+ builder.append(i.discoMultiAddrTCP);
+ builder.append(",");
+ builder.append(i.nodeRecord);
+ return builder.toString();
+ }
+
+ // from https://www.baeldung.com/java-csv
+ public String convertToCSV(String[] data) {
+ return Stream.of(data)
+ .map(this::escapeSpecialCharacters)
+ .collect(Collectors.joining(","));
+ }
+
+ public String escapeSpecialCharacters(String data) {
+ String escapedData = data.replaceAll("\\R", " ");
+ if (data.contains(",") || data.contains("\"") || data.contains("'")) {
+ data = data.replace("\"", "\"\"");
+ escapedData = "\"" + data + "\"";
+ }
+ return escapedData;
+ }
+
+ public NodeId getNodeId() {
+ return nodeId;
+ }
+
+ public PubKey getPubKey() {
+ return pubKey;
+ }
+
+ public String getENR() {
+ return network.getENR();
+ }
+
+ public Optional getDiscoveryAddress() {
+ return network.getDiscoveryAddress();
+ }
+
+ public int getP2PPeerCount() {
+ // return network.get
+ return network.getP2PPeerCount();
+ }
+
+ public Stream streamPeers() {
+ return network.streamPeers();
+ }
+
+ public Stream streamDiscoveryPeers() {
+ return network.streamKnownDiscoveryPeers();
+ }
+
+
+ @Override
+ protected void processMessage(Message zMessage) throws Exception {
+ logger.warn("P2PStart received message: " + zMessage.toString());
+
+ if(zMessage.isMessageType(P2P_START_SCAN)) {
+ p2pAddNewNodes();
+ // timer must be re-sent each time
+ PostTimerMessage(new TimerMessage(P2P_SCAN_INTERVAL, P2P_START_SCAN));
+ } else if(zMessage.isMessageType(P2P_SAVE_NEIGHBOURS)) {
+ // saveP2PNeighbours();
+ } else if(zMessage.isMessageType(P2P_STOP_SCAN)) {
+ // TODO: stop scanning
+ // also stop P2P layer?
+ }
+ }
+
+ private PrivKey loadNodePrivateKey(File mP2PNodePrivKeyFile) {
+ if (!mP2PNodePrivKeyFile.exists()) {
+ return null;
+ }
+ PrivKey privKey = null;
+ // try loading file from private key
+ // if error, bailout?
+ FileInputStream inputStream;
+ try {
+ inputStream = new FileInputStream(mP2PNodePrivKeyFile);
+ byte[] keyBuffer;
+ keyBuffer = inputStream.readAllBytes();
+ privKey = KeyKt.unmarshalPrivateKey(keyBuffer);
+ PubKey pubKey = privKey.publicKey();
+ System.out.println("Loaded private key from local dir: " + hex(privKey.bytes()));
+ System.out.println("Computed public key: " + hex(pubKey.bytes()));
+ } catch (FileNotFoundException e) {
+ System.out.println("Failed to read private key from disk - " + e.getMessage());
+ e.printStackTrace();
+ } catch (IOException e) {
+ System.out.println("Failed to read private key from disk - " + e.getMessage());
+ e.printStackTrace();
+ }
+ return privKey;
+ }
+
+ private PrivKey generateNodePrivateKey(File mP2PNodePrivKeyFile) {
+ // generate a SECP256K1 private key
+ // PrivateKeyProvider keyProvider = PrivateKeyGenerator::generate;
+ PrivKey privKey = KeyKt.generateKeyPair(KEY_TYPE.SECP256K1).component1();
+ // privKey = keyProvider.get();
+ // save priv key to file
+ try {
+ FileOutputStream outputStream = new FileOutputStream(mP2PNodePrivKeyFile);
+ outputStream.write(KeyKt.marshalPrivateKey(privKey));
+ //System.out.println("Generated new node private key and saved to local dir: " + hex(privKey.bytes()));
+ System.out.println("Computed node public key: " + hex(pubKey.bytes()));
+ outputStream.close();
+ } catch (Exception e) {
+ System.out.println("Failed to save node private key to disk - " + e.getMessage());
+ logger.error("Failed to save node private key to disk - " + e.getMessage());
+ }
+ return privKey;
+ }
+
+ private List> loadP2PNeighbours(File mP2PBootnodesFile) {
+ if(!mP2PBootnodesFile.exists()) {
+ return null;
+ }
+
+ // try loading bootnodes from CSV file
+ List> records = new ArrayList<>();
+ try (BufferedReader br = new BufferedReader(new FileReader(mP2PBootnodesFile))) {
+ String line;
+ logger.debug("starting to read p2p bootnodes CSV file: " + mP2PBootnodesFile.getAbsolutePath());
+ while ((line = br.readLine()) != null) {
+ if (line.length() > 0) {
+ String[] values = line.split(P2PStart.COMMA_DELIMITER);
+ logger.debug("P2PStart:csv load: read and CSV split one line: " + line);
+ if (values.length == 2) {
+ // expect public key, p2p multiaddr and ENR
+ // TODO: add fields validation
+ records.add(Arrays.asList(values));
+ //System.out.println("Loaded bootnode from CSV: " + records.get(records.size() - 1).toString());
+ logger.info("Loaded bootnode from CSV: " + records.get(records.size() - 1).toString());
+ } else {
+ logger.error("Failed to parse line from CSV: " + line);
+ System.out.println("P2P - error parsing line from CSV: " + line);
+ }
+ } else {
+ logger.debug("P2PStart: skipping empty line in CSV");
+ }
+ }
+ } catch (FileNotFoundException e) {
+
+ } catch (IOException e) {
+
+ }
+ return records;
+ }
+
+ private void saveP2PNeighbours() {
+ logger.debug("saveP2PNeighbours: trying to save neighbours list");
+ if(allDiscoveredNodes2.size() == 0) {
+ logger.debug("savep2pNeighbours: empty nodes list, nothing to save, exiting.");
+ return;
+ }
+ try {
+ //File csvOutputFile = new File(CSV_FILE_NAME);
+ File csvOutputFile = mP2PBootnodesFile;
+ FileWriter csvWriter = new FileWriter(csvOutputFile);
+ try (PrintWriter pw = new PrintWriter(csvWriter, true)) {
+ allDiscoveredNodes2.forEach(new BiConsumer() {
+ @Override
+ public void accept(String pubKey, MinimaNodeInfo i) {
+ logger.debug("saving node i: pubkey=" + pubKey + " enr=" + i.nodeRecord + " line=" + convertToCSV(pubKey, i));
+ pw.println(convertToCSV(pubKey, i));
+ }
+ });
+ } catch(Exception e) {
+ logger.warn("Could not write lines to neighbours list file! " + "msg=" + e.getMessage());
+ e.printStackTrace();
+ }
+ //csvWriter.flush();
+ } catch(IOException e) {
+ logger.warn("Could not flush and close neighbours list file! " + "msg=" + e.getMessage());
+ e.printStackTrace();
+ }
+ logger.debug("saveP2PNeighbours: end");
+ }
+
+ private void p2pAddNewNodes() {
+ logger.debug("p2pAddNewNodes: start");
+ if (network != null) {
+ Set activeKnownNodes = new HashSet<>();
+
+ // // we dont really care about this list...
+ // network.streamPeers().filter(peer -> peer.getId() != null).forEach(peer -> {
+ // logger.debug("peer: id=" + peer.getId()); // peer address == peer id and " isConnected=" true
+ // });
+
+ ArrayList mClients = mNetwork.getNetClients();
+
+ Set knownNodeIDs = new HashSet<>();
+
+ for (MinimaClient mClient : mClients) {
+ logger.debug(" mclient nodeid=" + mClient.getNodeID() + ", nodeRecord=" + mClient.getNodeRecord());
+ knownNodeIDs.add(mClient.getNodeID());
+ }
+
+ Set newActiveNodes = new HashSet<>();
+ Set unconnectedNewNodes = new HashSet<>();
+ network.streamKnownDiscoveryPeers().forEach(discoPeer -> { // disc peer node address should be
+ // inetsocketaddr
+ PeerId peerid = new PeerId(discoPeer.getNodeID().toArray());
+ // nodeAddress: enr_ip:enr_port
+ // pubkey:enr_secp256k1
+ // nodeid: derived(enr_secp256k1)
+ logger.debug("discovery peer: " + discoPeer.getNodeAddress() + " pubkey=" + discoPeer.getPublicKey()
+ + " peerid: " + peerid + " nodeid:" + discoPeer.getNodeID().toHexString() + " enr: "
+ + discoPeer.getNodeRecord());
+ // TODO: establish link between Bytes nodeID and libp2p nodeid / peerid
+ // TODO: verify values for nodeid and enr and filter existing nodes vs new based
+ // on nodeid
+ // Optional tmpdiscopeer =
+ // NodeRecordConverter.convertToDiscoveryPeer(discoPeer.getNodeRecord());
+
+ // nodeRecord.getNodeId()
+ newActiveNodes.add(discoPeer.getNodeAddress());
+
+ if (!knownNodeIDs.contains(discoPeer.getNodeID().toString())) {
+ logger.debug("FOUND NEW NODE: nodeid:" + discoPeer.getNodeID().toString() + " "
+ + discoPeer.getNodeRecord().toString());
+ MinimaNodeInfo aNewNodeInfo = new MinimaNodeInfo(discoPeer.getNodeID().toHexString(),
+ discoPeer.getNodeRecord().toString(), discoPeer.getNodeAddress(),
+ getDiscoMultiAddrTCPFromENR(discoPeer.getNodeRecord(), discoPeer.getPublicKey().toArray()));
+ unconnectedNewNodes.add(aNewNodeInfo);
+ allDiscoveredNodes2.put(aNewNodeInfo.nodeID, aNewNodeInfo);
+ } else {
+ logger.debug("SKIPPING an already connected node: nodeid:" + discoPeer.getNodeID().toHexString()
+ + " " + discoPeer.getNodeRecord().toString());
+ }
+ });
+
+ Set delta = new HashSet(newActiveNodes);
+ delta.removeAll(activeKnownNodes); // now contains only new sockets
+
+ for (MinimaNodeInfo i : unconnectedNewNodes) {
+ logger.info("New peer address: " + i.socket.toString().substring(1));
+ // TODO: replace ENR with nodeID, but P2PStart.nodeID is not the correct value
+ // (16... and not the bytes)
+ if (i.nodeRecord.compareTo(network.getENR()) == 0) {
+ logger.warn("IGNORING node ENR in list of new peers.");
+ } else if (i.nodeRecord == null || i.nodeID == null) {
+ logger.warn("IGNORING empty nodeRecord or nodeID.");
+ } else {
+ logger.info("CONNECTING to new ENR " + i.nodeRecord);
+ System.out.println("Starting MinimaClient: " + i.socket.toString().substring(1) + ":9001");
+ String nodeRecord = i.nodeRecord, nodeID = i.nodeID;
+ MinimaClient mclient = new MinimaClient(i.socket.getAddress().toString().substring(1), 9001,
+ mNetwork, nodeID, nodeRecord); // hardcode port for now
+ mNetwork.PostMessage(new Message(NetworkHandler.NETWORK_NEWCLIENT).addObject("client", mclient));
+ }
+ }
+
+ // update known nodes
+ activeKnownNodes = newActiveNodes;
+
+ // save list
+ saveP2PNeighbours();
+ // try {
+ // Thread.sleep(5000);
+ // PostMessage(P2P_START_SCAN);
+ // } catch(Exception e) {
+
+ // }
+ }
+ logger.debug("p2pAddNewNodes: end");
+ }
+
+ public String getDiscoMultiAddrTCPFromENR(String ENR, byte[] marshalledPubKey) {
+ NodeRecord nodeRecord = NodeRecordFactory.DEFAULT.fromEnr(ENR);
+ // extract multiaddress from nodeRecord
+ nodeRecord.getTcpAddress();
+ //nodeRecord.
+ StringBuilder strBuilder = new StringBuilder();
+ strBuilder.append("/ip4/");
+ strBuilder.append(nodeRecord.getTcpAddress().get().getAddress().getHostAddress());
+ strBuilder.append("/tcp/");
+ strBuilder.append(nodeRecord.getTcpAddress().get().getPort());
+ strBuilder.append("/p2p/");
+ // construct nodeid from public key
+ //discoPeer.getPublicKey()
+// new PubKey(KeyType.Secp256k1);
+ //PubKey hostPubKey = PubKey.fromString(discoPeer.getPublicKey());
+ //discoPeer.getPublicKey();
+// PubKey pubKey = Secp256k1Kt.unmarshalSecp256k1PublicKey(08021221 + discoPeer.getPublicKey().toArray());
+
+ PubKey pubKey = Secp256k1Kt.unmarshalSecp256k1PublicKey(marshalledPubKey);
+ PeerId pid = PeerId.fromPubKey(pubKey);
+ nodeId = new LibP2PNodeId(pid);
+ logger.debug("PubKey: " + hex(pubKey.bytes()));
+ logger.debug("pid: " + pid.toHex());
+ logger.debug("Built nodeid of discovered peer: " + nodeId.toBase58());
+ strBuilder.append(nodeId.toBase58());
+ logger.debug("Discovery TCP address: " + strBuilder.toString());
+ logger.debug("discover peer (enr fields): " + nodeRecord.toString());
+ return strBuilder.toString();
+ }
+
+ //TODO: refactor below code to use above object and constructor instead - if possible
+ public static void main(String[] args) throws ExecutionException, InterruptedException {
+ System.out.println("Hello world!");
+ }
+
+ private static File ensureFolder(File zFolder) {
+ if(!zFolder.exists()) {
+ zFolder.mkdirs();
+ }
+
+ return zFolder;
+ }
+
+}
diff --git a/src/org/minima/system/network/base/PortAvailability.java b/src/org/minima/system/network/base/PortAvailability.java
new file mode 100644
index 000000000..e915c5c69
--- /dev/null
+++ b/src/org/minima/system/network/base/PortAvailability.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2020 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import java.io.IOException;
+import java.net.DatagramSocket;
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class PortAvailability {
+ private static final Logger LOG = LogManager.getLogger();
+
+ public static boolean isPortAvailableForTcp(final int port) {
+ if (!isPortValid(port)) {
+ return false;
+ }
+ try (final ServerSocket serverSocket = new ServerSocket()) {
+ serverSocket.setReuseAddress(true);
+ serverSocket.bind(new InetSocketAddress(port));
+ return true;
+ } catch (IOException ex) {
+ LOG.trace(String.format("failed to open port %d for TCP", port), ex);
+ }
+ return false;
+ }
+
+ public static boolean isPortAvailableForUdp(final int port) {
+ if (!isPortValid(port)) {
+ return false;
+ }
+ try (final DatagramSocket datagramSocket = new DatagramSocket(null)) {
+ datagramSocket.setReuseAddress(true);
+ datagramSocket.bind(new InetSocketAddress(port));
+ return true;
+ } catch (IOException ex) {
+ LOG.trace(String.format("failed to open port %d for UDP", port), ex);
+ }
+ return false;
+ }
+
+ public static boolean isPortValid(final int port) {
+ return (port >= 0 && port <= 65535);
+ }
+
+ public static boolean isPortAvailable(final int port) {
+ return isPortAvailableForTcp(port) && isPortAvailableForUdp(port);
+ }
+}
diff --git a/src/org/minima/system/network/base/SafeFuture.java b/src/org/minima/system/network/base/SafeFuture.java
new file mode 100644
index 000000000..b09172fc7
--- /dev/null
+++ b/src/org/minima/system/network/base/SafeFuture.java
@@ -0,0 +1,637 @@
+/*
+ * Copyright 2019 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package org.minima.system.network.base;
+
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+public class SafeFuture extends CompletableFuture {
+
+ public static SafeFuture COMPLETE = SafeFuture.completedFuture(null);
+
+ public static void reportExceptions(final CompletionStage future) {
+ future.exceptionally(
+ error -> {
+ final Thread currentThread = Thread.currentThread();
+ currentThread.getUncaughtExceptionHandler().uncaughtException(currentThread, error);
+ return null;
+ });
+ }
+
+ public static > Consumer reportExceptions(
+ final Function action) {
+ return value -> reportExceptions(action.apply(value));
+ }
+
+ public static SafeFuture completedFuture(U value) {
+ SafeFuture future = new SafeFuture<>();
+ future.complete(value);
+ return future;
+ }
+
+ public static SafeFuture failedFuture(Throwable ex) {
+ SafeFuture future = new SafeFuture<>();
+ future.completeExceptionally(ex);
+ return future;
+ }
+
+ public static SafeFuture of(final CompletionStage stage) {
+ if (stage instanceof SafeFuture) {
+ return (SafeFuture) stage;
+ }
+ final SafeFuture safeFuture = new SafeFuture<>();
+ propagateResult(stage, safeFuture);
+ return safeFuture;
+ }
+
+ public static SafeFuture of(final ExceptionThrowingFutureSupplier futureSupplier) {
+ try {
+ return SafeFuture.of(futureSupplier.get());
+ } catch (Throwable e) {
+ return SafeFuture.failedFuture(e);
+ }
+ }
+
+ public static SafeFuture of(final ExceptionThrowingSupplier supplier) {
+ try {
+ return SafeFuture.completedFuture(supplier.get());
+ } catch (final Throwable e) {
+ return SafeFuture.failedFuture(e);
+ }
+ }
+
+ /**
+ * Creates a completed {@link SafeFuture} instance if none of the supplied interruptors are
+ * completed, else creates an exceptionally completed {@link SafeFuture} instance
+ *
+ * @see #orInterrupt(Interruptor...)
+ */
+ public static SafeFuture notInterrupted(Interruptor... interruptors) {
+ SafeFuture delayedFuture = new SafeFuture<>();
+ SafeFuture ret = delayedFuture.orInterrupt(interruptors);
+ delayedFuture.complete(null);
+ return ret;
+ }
+
+ /**
+ * Creates an {@link Interruptor} instance from the interrupting future and exception supplier for
+ * the case if interruption is triggered.
+ *
+ * The key feature of {@link Interruptor} and {@link #orInterrupt(Interruptor...)} method is
+ * that {@code interruptFuture} doesn't hold the reference to dependent futures after they
+ * complete. It's desired to consider this for long living interrupting futures to avoid memory
+ * leaks
+ *
+ * @param interruptFuture the future which triggers interruption when completes (normally or
+ * exceptionally)
+ * @param exceptionSupplier creates a desired exception if interruption is triggered
+ * @see #notInterrupted(Interruptor...)
+ * @see #orInterrupt(Interruptor...)
+ */
+ public static Interruptor createInterruptor(
+ CompletableFuture interruptFuture, Supplier exceptionSupplier) {
+ return new Interruptor(interruptFuture, exceptionSupplier);
+ }
+
+ /**
+ * Repeatedly run the loop until it returns false or completes exceptionally
+ *
+ * @param loopBody A supplier for generating futures to be run in succession
+ * @return A future that will complete when looping terminates
+ */
+ public static SafeFuture asyncDoWhile(ExceptionThrowingFutureSupplier loopBody) {
+ // Loop while futures complete immediately in order to avoid stack overflow due to recursion
+ SafeFuture loopFuture = SafeFuture.of(loopBody);
+ while (loopFuture.isCompletedNormally()) {
+ if (!loopFuture.join()) {
+ // Break if the result is false
+ break;
+ }
+ loopFuture = SafeFuture.of(loopBody);
+ }
+
+ return loopFuture.thenCompose(res -> res ? asyncDoWhile(loopBody) : SafeFuture.COMPLETE);
+ }
+
+ @SuppressWarnings("FutureReturnValueIgnored")
+ static void propagateResult(final CompletionStage stage, final SafeFuture safeFuture) {
+ stage.whenComplete(
+ (result, error) -> {
+ if (error != null) {
+ safeFuture.completeExceptionally(error);
+ } else {
+ safeFuture.complete(result);
+ }
+ });
+ }
+
+ public static SafeFuture fromRunnable(final ExceptionThrowingRunnable action) {
+ try {
+ action.run();
+ return SafeFuture.COMPLETE;
+ } catch (Throwable t) {
+ return SafeFuture.failedFuture(t);
+ }
+ }
+
+ public static SafeFuture allOf(final SafeFuture... futures) {
+ return of(CompletableFuture.allOf(futures))
+ .catchAndRethrow(completionException -> addSuppressedErrors(completionException, futures));
+ }
+
+ /**
+ * Adds the {@link Throwable} from each future as a suppressed exception to completionException
+ * unless it is already set as the cause.
+ *
+ * This ensures that when futures are combined with {@link #allOf(SafeFuture[])} that all
+ * failures are reported, not just the first one.
+ *
+ * @param completionException the exception reported by {@link
+ * CompletableFuture#allOf(CompletableFuture[])}
+ * @param futures the futures passed to allOf
+ */
+ @SuppressWarnings("FutureReturnValueIgnored")
+ public static void addSuppressedErrors(
+ final Throwable completionException, final SafeFuture[] futures) {
+ Stream.of(futures)
+ .forEach(
+ future ->
+ future.exceptionally(
+ error -> {
+ if (completionException.getCause() != error) {
+ completionException.addSuppressed(error);
+ }
+ return null;
+ }));
+ }
+
+ /**
+ * Returns a new SafeFuture that is completed when all of the given SafeFutures complete
+ * successfully or completes exceptionally immediately when any of the SafeFutures complete
+ * exceptionally. The results, if any, of the given SafeFutures are not reflected in the returned
+ * SafeFuture, but may be obtained by inspecting them individually. If no SafeFutures are
+ * provided, returns a SafeFuture completed with the value {@code null}.
+ *
+ *
Among the applications of this method is to await completion of a set of independent
+ * SafeFutures before continuing a program, as in: {@code SafeFuture.allOf(c1, c2, c3).join();}.
+ *
+ * @param futures the SafeFutures
+ * @return a new SafeFuture that is completed when all of the given SafeFutures complete
+ * @throws NullPointerException if the array or any of its elements are {@code null}
+ */
+ public static SafeFuture allOfFailFast(final SafeFuture... futures) {
+ final SafeFuture