docs: void connectEnvelope(Envelope envelope) throws TransactionException {
  
          if (shutdown) {
              logger.warn(format("%s not connecting is shutdown.", toString()));
              return;
          }
  
          final AtomicBoolean retry = new AtomicBoolean(true); // make sure we only retry connection once for each connection attempt.
  
          ManagedChannel lmanagedChannel = managedChannel;
  
          if (lmanagedChannel == null || lmanagedChannel.isTerminated() || lmanagedChannel.isShutdown()) {
  
              lmanagedChannel = channelBuilder.build();
              managedChannel = lmanagedChannel;
  
          }
  
          try {
  
              DeliverGrpc.DeliverStub broadcast = DeliverGrpc.newStub(lmanagedChannel);
  
              // final DeliverResponse[] ret = new DeliverResponse[1];
              //   final List<DeliverResponse> retList = new ArrayList<>();
              final List<Throwable> throwableList = new ArrayList<>();
              final CountDownLatch finishLatch = new CountDownLatch(1);
  
              so = new StreamObserver<DeliverResponse>() {
  
                  @Override
                  public void onNext(DeliverResponse resp) {
  
                      // logger.info("Got Broadcast response: " + resp);
                      logger.trace(format("DeliverResponse %s resp status value:%d  status %s, typecase %s ",
                              PeerEventServiceClient.this.toString(), resp.getStatusValue(), resp.getStatus(), resp.getTypeCase()));
  
                      final DeliverResponse.TypeCase typeCase = resp.getTypeCase();
  
                      if (typeCase == STATUS) {
  
                          logger.debug(format("DeliverResponse  %s setting done.",
                                  PeerEventServiceClient.this.toString()));
  
                          if (resp.getStatus() == Common.Status.SUCCESS) { // unlike you may think this only happens when all blocks are fetched.
                              peer.setLastConnectTime(System.currentTimeMillis());
                              peer.resetReconnectCount();
                          } else {
  
                              final long rec = peer.getReconnectCount();
  
                              PeerEventingServiceException peerEventingServiceException = new PeerEventingServiceException(format("%s attempts %s Status returned failure code %d (%s) during peer service event registration",
                                      PeerEventServiceClient.this.toString(), rec, resp.getStatusValue(), resp.getStatus().name()));
                              peerEventingServiceException.setResponse(resp);
                              if (rec % 10 == 0) {
                                  logger.warn(PeerEventServiceClient.this.toString() + " " + peerEventingServiceException.getMessage());
                              }
  
                              throwableList.add(peerEventingServiceException);
                          }
  
                      } else if (typeCase == FILTERED_BLOCK || typeCase == BLOCK) {
                          if (typeCase == BLOCK) {
                              logger.trace(format("%s got event block hex hashcode: %016x, block number: %d",
                                      PeerEventServiceClient.this.toString(), resp.getBlock().hashCode(), resp.getBlock().getHeader().getNumber()));
                          } else {
                              logger.trace(format("%s got event block hex hashcode: %016x, block number: %d",
                                      PeerEventServiceClient.this.toString(), resp.getFilteredBlock().hashCode(), resp.getFilteredBlock().getNumber()));
                          }
  
                          peer.setLastConnectTime(System.currentTimeMillis());
                          long reconnectCount = peer.getReconnectCount();
                          if (reconnectCount > 1) {
                              logger.info(format("%s reconnected after %d attempts on channel %s, peer %s, url %s",
                                      PeerEventServiceClient.this.toString(), reconnectCount, channelName, name, url));
                          }
                          peer.resetReconnectCount();
  
                          BlockEvent blockEvent = new BlockEvent(peer, resp);
                          peer.setLastBlockSeen(blockEvent);
  
                          channelEventQue.addBEvent(blockEvent);
                      } else {
                          logger.error(format("%s got event block with unknown type: %s, %d",
                                  PeerEventServiceClient.this.toString(), typeCase.name(), typeCase.getNumber()));
  
                          PeerEventingServiceException peerEventingServiceException = new PeerEventingServiceException(format("% got event block with unknown type: %s, %d",
                                  PeerEventServiceClient.this.toString(), typeCase.name(), typeCase.getNumber()));
                          peerEventingServiceException.setResponse(resp);
  
                          throwableList.add(peerEventingServiceException);
  
                      }
                      finishLatch.countDown();
  
                  }
  
                  @Override
                  public void onError(Throwable t) {
                      ManagedChannel llmanagedChannel = managedChannel;
                      if (llmanagedChannel != null) {
                          try {
                              llmanagedChannel.shutdownNow();
                          } catch (Exception e) {
                              logger.warn(format("Received error on %s, attempts %d. %s shut down of grpc channel.",
                                      PeerEventServiceClient.this.toString(), peer == null ? -1 : peer.getReconnectCount(), e.getMessage()), e);
                          }
                          managedChannel = null;
                      }
                      if (!shutdown) {
                          final long reconnectCount = peer.getReconnectCount();
                          if (PEER_EVENT_RECONNECTION_WARNING_RATE > 1 && reconnectCount % PEER_EVENT_RECONNECTION_WARNING_RATE == 1) {
                              logger.warn(format("Received error on  %s, attempts %d. %s",
                                      PeerEventServiceClient.this.toString(), reconnectCount, t.getMessage()));
  
                          } else {
                              logger.trace(format("Received error on %s, attempts %d. %s",
                                      PeerEventServiceClient.this.toString(), reconnectCount, t.getMessage()));
  
                          }
  
                          if (retry.getAndSet(false)) {
                              peer.reconnectPeerEventServiceClient(PeerEventServiceClient.this, t);
                          }
  
                      }
                      finishLatch.countDown();
                  }
  
                  @Override
                  public void onCompleted() {
                      logger.debug(format("DeliverResponse onCompleted %s setting done.",
                              PeerEventServiceClient.this.toString()));
                      //            done = true;
                      //There should have been a done before this...
                      finishLatch.countDown();
                  }
              };
  
              nso = filterBlock ? broadcast.deliverFiltered(so) : broadcast.deliver(so);
  
              nso.onNext(envelope);
  
              // try {
              if (!finishLatch.await(peerEventRegistrationWaitTimeMilliSecs, TimeUnit.MILLISECONDS)) {
                  PeerEventingServiceException ex = new PeerEventingServiceException(format(
                          "Channel %s connect time exceeded for peer eventing service %s, timed out at %d ms.", channelName, name, peerEventRegistrationWaitTimeMilliSecs));
                  ex.setTimedOut(peerEventRegistrationWaitTimeMilliSecs);
                  logger.warn(toString() + " " + ex.getMessage());
                  throwableList.add(0, ex);
  
              }
              logger.trace(toString() + " done waiting for reply!");
  
              if (!throwableList.isEmpty()) {
                  ManagedChannel llmanagedChannel = managedChannel;
                  if (llmanagedChannel != null) {
                      llmanagedChannel.shutdownNow();
                      managedChannel = null;
                  }
                  Throwable throwable = throwableList.get(0);
                  if (retry.getAndSet(false)) {
                      peer.reconnectPeerEventServiceClient(this, throwable);
                  }
  
              }
  
          } catch (InterruptedException e) {
              ManagedChannel llmanagedChannel = managedChannel;
              if (llmanagedChannel != null) {
                  llmanagedChannel.shutdownNow();
                  managedChannel = null;
              }
              logger.error(toString() + " error message: " + e.getMessage(), e); // not likely
  
              if (retry.getAndSet(false)) {
                  peer.reconnectPeerEventServiceClient(this, e);
              }
  
          } finally {
              if (null != nso) {
  
                  try {
                      nso.onCompleted();
                  } catch (Exception e) {  //Best effort only report on debug
                      logger.debug(format("Exception completing connect with %s %s",
                              toString(), e.getMessage()), e);
                  }
  
              }
          }
      }