import com.google.bitcoin.protocols.channels.PaymentChannelCloseException.CloseReason; //导入依赖的package包/类
@GuardedBy("lock")
private void receiveClose(Protos.TwoWayChannelMessage msg) throws VerificationException {
    checkState(lock.isHeldByCurrentThread());
    if (msg.hasSettlement()) {
        Transaction settleTx = new Transaction(wallet.getParams(), msg.getSettlement().getTx().toByteArray());
        log.info("CLOSE message received with settlement tx {}", settleTx.getHash());
        // TODO: set source
        if (state != null && state().isSettlementTransaction(settleTx)) {
            // The wallet has a listener on it that the state object will use to do the right thing at this
            // point (like watching it for confirmations). The tx has been checked by now for syntactical validity
            // and that it correctly spends the multisig contract.
            wallet.receivePending(settleTx, null);
        }
    } else {
        log.info("CLOSE message received without settlement tx");
    }
    if (step == InitStep.WAITING_FOR_CHANNEL_CLOSE)
        conn.destroyConnection(CloseReason.CLIENT_REQUESTED_CLOSE);
    else
        conn.destroyConnection(CloseReason.SERVER_REQUESTED_CLOSE);
    step = InitStep.CHANNEL_CLOSED;
}
 

import com.google.bitcoin.protocols.channels.PaymentChannelCloseException.CloseReason; //导入依赖的package包/类
@GuardedBy("lock")
private void receiveUpdatePaymentMessage(Protos.UpdatePayment msg, boolean sendAck) throws VerificationException, ValueOutOfRangeException, InsufficientMoneyException {
    log.info("Got a payment update");

    BigInteger lastBestPayment = state.getBestValueToMe();
    final BigInteger refundSize = BigInteger.valueOf(msg.getClientChangeValue());
    boolean stillUsable = state.incrementPayment(refundSize, msg.getSignature().toByteArray());
    BigInteger bestPaymentChange = state.getBestValueToMe().subtract(lastBestPayment);

    if (bestPaymentChange.signum() > 0)
        conn.paymentIncrease(bestPaymentChange, state.getBestValueToMe());

    if (sendAck) {
        Protos.TwoWayChannelMessage.Builder ack = Protos.TwoWayChannelMessage.newBuilder();
        ack.setType(Protos.TwoWayChannelMessage.MessageType.PAYMENT_ACK);
        conn.sendToClient(ack.build());
    }

    if (!stillUsable) {
        log.info("Channel is now fully exhausted, closing/initiating settlement");
        settlePayment(CloseReason.CHANNEL_EXHAUSTED);
    }
}
 

import com.google.bitcoin.protocols.channels.PaymentChannelCloseException.CloseReason; //导入依赖的package包/类
@GuardedBy("lock")
private void receiveUpdatePaymentMessage(Protos.UpdatePayment msg, boolean sendAck) throws VerificationException, ValueOutOfRangeException, InsufficientMoneyException {
    log.info("Got a payment update");

    BigInteger lastBestPayment = state.getBestValueToMe();
    final BigInteger refundSize = BigInteger.valueOf(msg.getClientChangeValue());
    boolean stillUsable = state.incrementPayment(refundSize, msg.getSignature().toByteArray());
    BigInteger bestPaymentChange = state.getBestValueToMe().subtract(lastBestPayment);

    if (bestPaymentChange.compareTo(BigInteger.ZERO) > 0)
        conn.paymentIncrease(bestPaymentChange, state.getBestValueToMe());

    if (sendAck) {
        Protos.TwoWayChannelMessage.Builder ack = Protos.TwoWayChannelMessage.newBuilder();
        ack.setType(Protos.TwoWayChannelMessage.MessageType.PAYMENT_ACK);
        conn.sendToClient(ack.build());
    }

    if (!stillUsable) {
        log.info("Channel is now fully exhausted, closing/initiating settlement");
        settlePayment(CloseReason.CHANNEL_EXHAUSTED);
    }
}
 

import com.google.bitcoin.protocols.channels.PaymentChannelCloseException.CloseReason; //导入依赖的package包/类
@GuardedBy("lock")
private void receiveUpdatePaymentMessage(Protos.TwoWayChannelMessage msg) throws VerificationException, ValueOutOfRangeException {
    checkState(step == InitStep.CHANNEL_OPEN && msg.hasUpdatePayment());
    log.info("Got a payment update");

    Protos.UpdatePayment updatePayment = msg.getUpdatePayment();
    BigInteger lastBestPayment = state.getBestValueToMe();
    final BigInteger refundSize = BigInteger.valueOf(updatePayment.getClientChangeValue());
    boolean stillUsable = state.incrementPayment(refundSize, updatePayment.getSignature().toByteArray());
    BigInteger bestPaymentChange = state.getBestValueToMe().subtract(lastBestPayment);

    if (bestPaymentChange.compareTo(BigInteger.ZERO) > 0)
        conn.paymentIncrease(bestPaymentChange, state.getBestValueToMe());

    Protos.TwoWayChannelMessage.Builder ack = Protos.TwoWayChannelMessage.newBuilder();
    ack.setType(Protos.TwoWayChannelMessage.MessageType.PAYMENT_ACK);
    conn.sendToClient(ack.build());

    if (!stillUsable) {
        log.info("Channel is now fully exhausted, closing/initiating settlement");
        settlePayment(CloseReason.CHANNEL_EXHAUSTED);
    }
}
 

import com.google.bitcoin.protocols.channels.PaymentChannelCloseException.CloseReason; //导入依赖的package包/类
private void error(String message, Protos.Error.ErrorCode errorCode, CloseReason closeReason) {
    log.error(message);
    Protos.Error.Builder errorBuilder;
    errorBuilder = Protos.Error.newBuilder()
            .setCode(errorCode)
            .setExplanation(message);
    conn.sendToClient(Protos.TwoWayChannelMessage.newBuilder()
            .setError(errorBuilder)
            .setType(Protos.TwoWayChannelMessage.MessageType.ERROR)
            .build());
    conn.destroyConnection(closeReason);
}
 

import com.google.bitcoin.protocols.channels.PaymentChannelCloseException.CloseReason; //导入依赖的package包/类
@GuardedBy("lock")
private void receiveCloseMessage() throws InsufficientMoneyException {
    log.info("Got CLOSE message, closing channel");
    if (state != null) {
        settlePayment(CloseReason.CLIENT_REQUESTED_CLOSE);
    } else {
        conn.destroyConnection(CloseReason.CLIENT_REQUESTED_CLOSE);
    }
}
 

import com.google.bitcoin.protocols.channels.PaymentChannelCloseException.CloseReason; //导入依赖的package包/类
@GuardedBy("lock")
private void settlePayment(final CloseReason clientRequestedClose) throws InsufficientMoneyException {
    // Setting channelSettling here prevents us from sending another CLOSE when state.close() calls
    // close() on us here below via the stored channel state.
    // TODO: Strongly separate the lifecycle of the payment channel from the TCP connection in these classes.
    channelSettling = true;
    Futures.addCallback(state.close(), new FutureCallback<Transaction>() {
        @Override
        public void onSuccess(Transaction result) {
            // Send the successfully accepted transaction back to the client.
            final Protos.TwoWayChannelMessage.Builder msg = Protos.TwoWayChannelMessage.newBuilder();
            msg.setType(Protos.TwoWayChannelMessage.MessageType.CLOSE);
            if (result != null) {
                // Result can be null on various error paths, like if we never actually opened
                // properly and so on.
                msg.getSettlementBuilder().setTx(ByteString.copyFrom(result.bitcoinSerialize()));
                log.info("Sending CLOSE back with broadcast settlement tx.");
            } else {
                log.info("Sending CLOSE back without broadcast settlement tx.");
            }
            conn.sendToClient(msg.build());
            conn.destroyConnection(clientRequestedClose);
        }

        @Override
        public void onFailure(Throwable t) {
            log.error("Failed to broadcast settlement tx", t);
            conn.destroyConnection(clientRequestedClose);
        }
    });
}
 

import com.google.bitcoin.protocols.channels.PaymentChannelCloseException.CloseReason; //导入依赖的package包/类
/**
 * <p>Closes the connection by generating a settle message for the client and calls
 * {@link ServerConnection#destroyConnection(CloseReason)}. Note that this does not broadcast
 * the payment transaction and the client may still resume the same channel if they reconnect</p>
 *
 * <p>Note that {@link PaymentChannelServer#connectionClosed()} must still be called after the connection fully
 * closes.</p>
 */
public void close() {
    lock.lock();
    try {
        if (connectionOpen && !channelSettling) {
            final Protos.TwoWayChannelMessage.Builder msg = Protos.TwoWayChannelMessage.newBuilder();
            msg.setType(Protos.TwoWayChannelMessage.MessageType.CLOSE);
            conn.sendToClient(msg.build());
            conn.destroyConnection(CloseReason.SERVER_REQUESTED_CLOSE);
        }
    } finally {
        lock.unlock();
    }
}