private static void writeConfidence(
      Protos.Transaction.Builder txBuilder,
      TransactionConfidence confidence,
      Protos.TransactionConfidence.Builder confidenceBuilder) {
    synchronized (confidence) {
      confidenceBuilder.setType(
          Protos.TransactionConfidence.Type.valueOf(confidence.getConfidenceType().getValue()));
      if (confidence.getConfidenceType() == ConfidenceType.BUILDING) {
        confidenceBuilder.setAppearedAtHeight(confidence.getAppearedAtChainHeight());
        confidenceBuilder.setDepth(confidence.getDepthInBlocks());
      }
      if (confidence.getConfidenceType() == ConfidenceType.DEAD) {
        // Copy in the overriding transaction, if available.
        // (A dead coinbase transaction has no overriding transaction).
        if (confidence.getOverridingTransaction() != null) {
          Sha256Hash overridingHash = confidence.getOverridingTransaction().getHash();
          confidenceBuilder.setOverridingTransaction(hashToByteString(overridingHash));
        }
      }
      TransactionConfidence.Source source = confidence.getSource();
      switch (source) {
        case SELF:
          confidenceBuilder.setSource(Protos.TransactionConfidence.Source.SOURCE_SELF);
          break;
        case NETWORK:
          confidenceBuilder.setSource(Protos.TransactionConfidence.Source.SOURCE_NETWORK);
          break;
        case UNKNOWN:
          // Fall through.
        default:
          confidenceBuilder.setSource(Protos.TransactionConfidence.Source.SOURCE_UNKNOWN);
          break;
      }
    }

    for (ListIterator<PeerAddress> it = confidence.getBroadcastBy(); it.hasNext(); ) {
      PeerAddress address = it.next();
      Protos.PeerAddress proto =
          Protos.PeerAddress.newBuilder()
              .setIpAddress(ByteString.copyFrom(address.getAddr().getAddress()))
              .setPort(address.getPort())
              .setServices(address.getServices().longValue())
              .build();
      confidenceBuilder.addBroadcastBy(proto);
    }
    txBuilder.setConfidence(confidenceBuilder);
  }
 private void readConfidence(
     Transaction tx,
     Protos.TransactionConfidence confidenceProto,
     TransactionConfidence confidence)
     throws UnreadableWalletException {
   // We are lenient here because tx confidence is not an essential part of the wallet.
   // If the tx has an unknown type of confidence, ignore.
   if (!confidenceProto.hasType()) {
     log.warn("Unknown confidence type for tx {}", tx.getHashAsString());
     return;
   }
   ConfidenceType confidenceType;
   switch (confidenceProto.getType()) {
     case BUILDING:
       confidenceType = ConfidenceType.BUILDING;
       break;
     case DEAD:
       confidenceType = ConfidenceType.DEAD;
       break;
       // These two are equivalent (must be able to read old wallets).
     case NOT_IN_BEST_CHAIN:
       confidenceType = ConfidenceType.PENDING;
       break;
     case PENDING:
       confidenceType = ConfidenceType.PENDING;
       break;
     case UNKNOWN:
       // Fall through.
     default:
       confidenceType = ConfidenceType.UNKNOWN;
       break;
   }
   confidence.setConfidenceType(confidenceType);
   if (confidenceProto.hasAppearedAtHeight()) {
     if (confidence.getConfidenceType() != ConfidenceType.BUILDING) {
       log.warn("Have appearedAtHeight but not BUILDING for tx {}", tx.getHashAsString());
       return;
     }
     confidence.setAppearedAtChainHeight(confidenceProto.getAppearedAtHeight());
   }
   if (confidenceProto.hasDepth()) {
     if (confidence.getConfidenceType() != ConfidenceType.BUILDING) {
       log.warn("Have depth but not BUILDING for tx {}", tx.getHashAsString());
       return;
     }
     confidence.setDepthInBlocks(confidenceProto.getDepth());
   }
   if (confidenceProto.hasOverridingTransaction()) {
     if (confidence.getConfidenceType() != ConfidenceType.DEAD) {
       log.warn("Have overridingTransaction but not OVERRIDDEN for tx {}", tx.getHashAsString());
       return;
     }
     Transaction overridingTransaction = txMap.get(confidenceProto.getOverridingTransaction());
     if (overridingTransaction == null) {
       log.warn(
           "Have overridingTransaction that is not in wallet for tx {}", tx.getHashAsString());
       return;
     }
     confidence.setOverridingTransaction(overridingTransaction);
   }
   for (Protos.PeerAddress proto : confidenceProto.getBroadcastByList()) {
     InetAddress ip;
     try {
       ip = InetAddress.getByAddress(proto.getIpAddress().toByteArray());
     } catch (UnknownHostException e) {
       throw new UnreadableWalletException("Peer IP address does not have the right length", e);
     }
     int port = proto.getPort();
     PeerAddress address = new PeerAddress(ip, port);
     address.setServices(BigInteger.valueOf(proto.getServices()));
     confidence.markBroadcastBy(address);
   }
   switch (confidenceProto.getSource()) {
     case SOURCE_SELF:
       confidence.setSource(TransactionConfidence.Source.SELF);
       break;
     case SOURCE_NETWORK:
       confidence.setSource(TransactionConfidence.Source.NETWORK);
       break;
     case SOURCE_UNKNOWN:
       // Fall through.
     default:
       confidence.setSource(TransactionConfidence.Source.UNKNOWN);
       break;
   }
 }