imToken v3.28.8 - Protos.java 源代码

package org.bitcoin.paymentchannel;

import com.google.protobuf.AbstractParser;
import com.google.protobuf.ByteString;
import com.google.protobuf.CodedInputStream;
import com.google.protobuf.CodedOutputStream;
import com.google.protobuf.Descriptors;
import com.google.protobuf.ExtensionRegistry;
import com.google.protobuf.ExtensionRegistryLite;
import com.google.protobuf.GeneratedMessage;
import com.google.protobuf.Internal;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.Message;
import com.google.protobuf.MessageOrBuilder;
import com.google.protobuf.Parser;
import com.google.protobuf.ProtocolMessageEnum;
import com.google.protobuf.SingleFieldBuilder;
import com.google.protobuf.UnknownFieldSet;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectStreamException;
import net.minidev.json.parser.JSONParser;
import org.bitcoinj.protocols.channels.PaymentChannelClient;

public final class Protos {
    private static Descriptors.FileDescriptor descriptor;
    private static final Descriptors.Descriptor internal_static_paymentchannels_ClientVersion_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_paymentchannels_ClientVersion_fieldAccessorTable;
    private static final Descriptors.Descriptor internal_static_paymentchannels_Error_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_paymentchannels_Error_fieldAccessorTable;
    private static final Descriptors.Descriptor internal_static_paymentchannels_Initiate_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_paymentchannels_Initiate_fieldAccessorTable;
    private static final Descriptors.Descriptor internal_static_paymentchannels_PaymentAck_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_paymentchannels_PaymentAck_fieldAccessorTable;
    private static final Descriptors.Descriptor internal_static_paymentchannels_ProvideContract_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_paymentchannels_ProvideContract_fieldAccessorTable;
    private static final Descriptors.Descriptor internal_static_paymentchannels_ProvideRefund_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_paymentchannels_ProvideRefund_fieldAccessorTable;
    private static final Descriptors.Descriptor internal_static_paymentchannels_ReturnRefund_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_paymentchannels_ReturnRefund_fieldAccessorTable;
    private static final Descriptors.Descriptor internal_static_paymentchannels_ServerVersion_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_paymentchannels_ServerVersion_fieldAccessorTable;
    private static final Descriptors.Descriptor internal_static_paymentchannels_Settlement_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_paymentchannels_Settlement_fieldAccessorTable;
    private static final Descriptors.Descriptor internal_static_paymentchannels_TwoWayChannelMessage_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_paymentchannels_TwoWayChannelMessage_fieldAccessorTable;
    private static final Descriptors.Descriptor internal_static_paymentchannels_UpdatePayment_descriptor;
    private static GeneratedMessage.FieldAccessorTable internal_static_paymentchannels_UpdatePayment_fieldAccessorTable;

    public interface ClientVersionOrBuilder extends MessageOrBuilder {
        int getMajor();

        int getMinor();

        ByteString getPreviousChannelContractHash();

        long getTimeWindowSecs();

        boolean hasMajor();

        boolean hasMinor();

        boolean hasPreviousChannelContractHash();

        boolean hasTimeWindowSecs();
    }

    public interface ErrorOrBuilder extends MessageOrBuilder {
        Error.ErrorCode getCode();

        long getExpectedValue();

        String getExplanation();

        ByteString getExplanationBytes();

        boolean hasCode();

        boolean hasExpectedValue();

        boolean hasExplanation();
    }

    public interface InitiateOrBuilder extends MessageOrBuilder {
        long getExpireTimeSecs();

        long getMinAcceptedChannelSize();

        long getMinPayment();

        ByteString getMultisigKey();

        boolean hasExpireTimeSecs();

        boolean hasMinAcceptedChannelSize();

        boolean hasMinPayment();

        boolean hasMultisigKey();
    }

    public interface PaymentAckOrBuilder extends MessageOrBuilder {
        ByteString getInfo();

        boolean hasInfo();
    }

    public interface ProvideContractOrBuilder extends MessageOrBuilder {
        ByteString getClientKey();

        UpdatePayment getInitialPayment();

        UpdatePaymentOrBuilder getInitialPaymentOrBuilder();

        ByteString getTx();

        boolean hasClientKey();

        boolean hasInitialPayment();

        boolean hasTx();
    }

    public interface ProvideRefundOrBuilder extends MessageOrBuilder {
        ByteString getMultisigKey();

        ByteString getTx();

        boolean hasMultisigKey();

        boolean hasTx();
    }

    public interface ReturnRefundOrBuilder extends MessageOrBuilder {
        ByteString getSignature();

        boolean hasSignature();
    }

    public interface ServerVersionOrBuilder extends MessageOrBuilder {
        int getMajor();

        int getMinor();

        boolean hasMajor();

        boolean hasMinor();
    }

    public interface SettlementOrBuilder extends MessageOrBuilder {
        ByteString getTx();

        boolean hasTx();
    }

    public interface TwoWayChannelMessageOrBuilder extends MessageOrBuilder {
        ClientVersion getClientVersion();

        ClientVersionOrBuilder getClientVersionOrBuilder();

        Error getError();

        ErrorOrBuilder getErrorOrBuilder();

        Initiate getInitiate();

        InitiateOrBuilder getInitiateOrBuilder();

        PaymentAck getPaymentAck();

        PaymentAckOrBuilder getPaymentAckOrBuilder();

        ProvideContract getProvideContract();

        ProvideContractOrBuilder getProvideContractOrBuilder();

        ProvideRefund getProvideRefund();

        ProvideRefundOrBuilder getProvideRefundOrBuilder();

        ReturnRefund getReturnRefund();

        ReturnRefundOrBuilder getReturnRefundOrBuilder();

        ServerVersion getServerVersion();

        ServerVersionOrBuilder getServerVersionOrBuilder();

        Settlement getSettlement();

        SettlementOrBuilder getSettlementOrBuilder();

        TwoWayChannelMessage.MessageType getType();

        UpdatePayment getUpdatePayment();

        UpdatePaymentOrBuilder getUpdatePaymentOrBuilder();

        boolean hasClientVersion();

        boolean hasError();

        boolean hasInitiate();

        boolean hasPaymentAck();

        boolean hasProvideContract();

        boolean hasProvideRefund();

        boolean hasReturnRefund();

        boolean hasServerVersion();

        boolean hasSettlement();

        boolean hasType();

        boolean hasUpdatePayment();
    }

    public interface UpdatePaymentOrBuilder extends MessageOrBuilder {
        long getClientChangeValue();

        ByteString getInfo();

        ByteString getSignature();

        boolean hasClientChangeValue();

        boolean hasInfo();

        boolean hasSignature();
    }

    public static void registerAllExtensions(ExtensionRegistry extensionRegistry) {
    }

    private Protos() {
    }

    public static final class TwoWayChannelMessage extends GeneratedMessage implements TwoWayChannelMessageOrBuilder {
        public static final int CLIENT_VERSION_FIELD_NUMBER = 2;
        public static final int ERROR_FIELD_NUMBER = 10;
        public static final int INITIATE_FIELD_NUMBER = 4;
        public static Parser<TwoWayChannelMessage> PARSER = new AbstractParser<TwoWayChannelMessage>() {
            public TwoWayChannelMessage parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new TwoWayChannelMessage(codedInputStream, extensionRegistryLite);
            }
        };
        public static final int PAYMENT_ACK_FIELD_NUMBER = 11;
        public static final int PROVIDE_CONTRACT_FIELD_NUMBER = 7;
        public static final int PROVIDE_REFUND_FIELD_NUMBER = 5;
        public static final int RETURN_REFUND_FIELD_NUMBER = 6;
        public static final int SERVER_VERSION_FIELD_NUMBER = 3;
        public static final int SETTLEMENT_FIELD_NUMBER = 9;
        public static final int TYPE_FIELD_NUMBER = 1;
        public static final int UPDATE_PAYMENT_FIELD_NUMBER = 8;
        private static final TwoWayChannelMessage defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private ClientVersion clientVersion_;
        private Error error_;
        private Initiate initiate_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private PaymentAck paymentAck_;
        private ProvideContract provideContract_;
        private ProvideRefund provideRefund_;
        private ReturnRefund returnRefund_;
        private ServerVersion serverVersion_;
        private Settlement settlement_;
        private MessageType type_;
        private final UnknownFieldSet unknownFields;
        private UpdatePayment updatePayment_;

        private TwoWayChannelMessage(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private TwoWayChannelMessage(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static TwoWayChannelMessage getDefaultInstance() {
            return defaultInstance;
        }

        public TwoWayChannelMessage m1801getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private TwoWayChannelMessage(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        int readTag = codedInputStream.readTag();
                        switch (readTag) {
                            case 0:
                                z = true;
                            case 8:
                                int readEnum = codedInputStream.readEnum();
                                MessageType valueOf = MessageType.valueOf(readEnum);
                                if (valueOf == null) {
                                    newBuilder.mergeVarintField(1, readEnum);
                                } else {
                                    this.bitField0_ |= 1;
                                    this.type_ = valueOf;
                                }
                            case 18:
                                ClientVersion.Builder m1535toBuilder = (this.bitField0_ & 2) == 2 ? this.clientVersion_.m1535toBuilder() : null;
                                ClientVersion clientVersion = (ClientVersion) codedInputStream.readMessage(ClientVersion.PARSER, extensionRegistryLite);
                                this.clientVersion_ = clientVersion;
                                if (m1535toBuilder != null) {
                                    m1535toBuilder.mergeFrom(clientVersion);
                                    this.clientVersion_ = m1535toBuilder.m1540buildPartial();
                                }
                                this.bitField0_ |= 2;
                            case 26:
                                ServerVersion.Builder m1746toBuilder = (this.bitField0_ & 4) == 4 ? this.serverVersion_.m1746toBuilder() : null;
                                ServerVersion serverVersion = (ServerVersion) codedInputStream.readMessage(ServerVersion.PARSER, extensionRegistryLite);
                                this.serverVersion_ = serverVersion;
                                if (m1746toBuilder != null) {
                                    m1746toBuilder.mergeFrom(serverVersion);
                                    this.serverVersion_ = m1746toBuilder.m1751buildPartial();
                                }
                                this.bitField0_ |= 4;
                            case 34:
                                Initiate.Builder m1596toBuilder = (this.bitField0_ & 8) == 8 ? this.initiate_.m1596toBuilder() : null;
                                Initiate initiate = (Initiate) codedInputStream.readMessage(Initiate.PARSER, extensionRegistryLite);
                                this.initiate_ = initiate;
                                if (m1596toBuilder != null) {
                                    m1596toBuilder.mergeFrom(initiate);
                                    this.initiate_ = m1596toBuilder.m1601buildPartial();
                                }
                                this.bitField0_ |= 8;
                            case 42:
                                ProvideRefund.Builder m1686toBuilder = (this.bitField0_ & 16) == 16 ? this.provideRefund_.m1686toBuilder() : null;
                                ProvideRefund provideRefund = (ProvideRefund) codedInputStream.readMessage(ProvideRefund.PARSER, extensionRegistryLite);
                                this.provideRefund_ = provideRefund;
                                if (m1686toBuilder != null) {
                                    m1686toBuilder.mergeFrom(provideRefund);
                                    this.provideRefund_ = m1686toBuilder.m1691buildPartial();
                                }
                                this.bitField0_ |= 16;
                            case 50:
                                ReturnRefund.Builder m1716toBuilder = (this.bitField0_ & 32) == 32 ? this.returnRefund_.m1716toBuilder() : null;
                                ReturnRefund returnRefund = (ReturnRefund) codedInputStream.readMessage(ReturnRefund.PARSER, extensionRegistryLite);
                                this.returnRefund_ = returnRefund;
                                if (m1716toBuilder != null) {
                                    m1716toBuilder.mergeFrom(returnRefund);
                                    this.returnRefund_ = m1716toBuilder.m1721buildPartial();
                                }
                                this.bitField0_ |= 32;
                            case 58:
                                ProvideContract.Builder m1656toBuilder = (this.bitField0_ & 64) == 64 ? this.provideContract_.m1656toBuilder() : null;
                                ProvideContract provideContract = (ProvideContract) codedInputStream.readMessage(ProvideContract.PARSER, extensionRegistryLite);
                                this.provideContract_ = provideContract;
                                if (m1656toBuilder != null) {
                                    m1656toBuilder.mergeFrom(provideContract);
                                    this.provideContract_ = m1656toBuilder.m1661buildPartial();
                                }
                                this.bitField0_ |= 64;
                            case 66:
                                UpdatePayment.Builder m1837toBuilder = (this.bitField0_ & 128) == 128 ? this.updatePayment_.m1837toBuilder() : null;
                                UpdatePayment updatePayment = (UpdatePayment) codedInputStream.readMessage(UpdatePayment.PARSER, extensionRegistryLite);
                                this.updatePayment_ = updatePayment;
                                if (m1837toBuilder != null) {
                                    m1837toBuilder.mergeFrom(updatePayment);
                                    this.updatePayment_ = m1837toBuilder.m1842buildPartial();
                                }
                                this.bitField0_ |= 128;
                            case 74:
                                Settlement.Builder m1776toBuilder = (this.bitField0_ & 512) == 512 ? this.settlement_.m1776toBuilder() : null;
                                Settlement settlement = (Settlement) codedInputStream.readMessage(Settlement.PARSER, extensionRegistryLite);
                                this.settlement_ = settlement;
                                if (m1776toBuilder != null) {
                                    m1776toBuilder.mergeFrom(settlement);
                                    this.settlement_ = m1776toBuilder.m1781buildPartial();
                                }
                                this.bitField0_ |= 512;
                            case 82:
                                Error.Builder m1565toBuilder = (this.bitField0_ & 1024) == 1024 ? this.error_.m1565toBuilder() : null;
                                Error error = (Error) codedInputStream.readMessage(Error.PARSER, extensionRegistryLite);
                                this.error_ = error;
                                if (m1565toBuilder != null) {
                                    m1565toBuilder.mergeFrom(error);
                                    this.error_ = m1565toBuilder.m1570buildPartial();
                                }
                                this.bitField0_ |= 1024;
                            case 90:
                                PaymentAck.Builder m1626toBuilder = (this.bitField0_ & JSONParser.ACCEPT_TAILLING_DATA) == 256 ? this.paymentAck_.m1626toBuilder() : null;
                                PaymentAck paymentAck = (PaymentAck) codedInputStream.readMessage(PaymentAck.PARSER, extensionRegistryLite);
                                this.paymentAck_ = paymentAck;
                                if (m1626toBuilder != null) {
                                    m1626toBuilder.mergeFrom(paymentAck);
                                    this.paymentAck_ = m1626toBuilder.m1631buildPartial();
                                }
                                this.bitField0_ |= JSONParser.ACCEPT_TAILLING_DATA;
                            default:
                                if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                    z = true;
                                }
                        }
                    } catch (InvalidProtocolBufferException e) {
                        throw e.setUnfinishedMessage(this);
                    } catch (IOException e2) {
                        throw new InvalidProtocolBufferException(e2.getMessage()).setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return Protos.internal_static_paymentchannels_TwoWayChannelMessage_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return Protos.internal_static_paymentchannels_TwoWayChannelMessage_fieldAccessorTable.ensureFieldAccessorsInitialized(TwoWayChannelMessage.class, Builder.class);
        }

        static {
            TwoWayChannelMessage twoWayChannelMessage = new TwoWayChannelMessage(true);
            defaultInstance = twoWayChannelMessage;
            twoWayChannelMessage.initFields();
        }

        public Parser<TwoWayChannelMessage> getParserForType() {
            return PARSER;
        }

        public enum MessageType implements ProtocolMessageEnum {
            CLIENT_VERSION(0, 1),
            SERVER_VERSION(1, 2),
            INITIATE(2, 3),
            PROVIDE_REFUND(3, 4),
            RETURN_REFUND(4, 5),
            PROVIDE_CONTRACT(5, 6),
            CHANNEL_OPEN(6, 7),
            UPDATE_PAYMENT(7, 8),
            PAYMENT_ACK(8, 11),
            CLOSE(9, 9),
            ERROR(10, 10);

            public static final int CHANNEL_OPEN_VALUE = 7;
            public static final int CLIENT_VERSION_VALUE = 1;
            public static final int CLOSE_VALUE = 9;
            public static final int ERROR_VALUE = 10;
            public static final int INITIATE_VALUE = 3;
            public static final int PAYMENT_ACK_VALUE = 11;
            public static final int PROVIDE_CONTRACT_VALUE = 6;
            public static final int PROVIDE_REFUND_VALUE = 4;
            public static final int RETURN_REFUND_VALUE = 5;
            public static final int SERVER_VERSION_VALUE = 2;
            public static final int UPDATE_PAYMENT_VALUE = 8;
            private final int index;
            private final int value;
            private static Internal.EnumLiteMap<MessageType> internalValueMap = new Internal.EnumLiteMap<MessageType>() {
                public MessageType findValueByNumber(int i) {
                    return MessageType.valueOf(i);
                }
            };
            private static final MessageType[] VALUES = values();

            public final int getNumber() {
                return this.value;
            }

            public static MessageType valueOf(int i) {
                switch (i) {
                    case 1:
                        return CLIENT_VERSION;
                    case 2:
                        return SERVER_VERSION;
                    case 3:
                        return INITIATE;
                    case 4:
                        return PROVIDE_REFUND;
                    case 5:
                        return RETURN_REFUND;
                    case 6:
                        return PROVIDE_CONTRACT;
                    case 7:
                        return CHANNEL_OPEN;
                    case 8:
                        return UPDATE_PAYMENT;
                    case 9:
                        return CLOSE;
                    case 10:
                        return ERROR;
                    case 11:
                        return PAYMENT_ACK;
                    default:
                        return null;
                }
            }

            public static Internal.EnumLiteMap<MessageType> internalGetValueMap() {
                return internalValueMap;
            }

            public final Descriptors.EnumValueDescriptor getValueDescriptor() {
                return (Descriptors.EnumValueDescriptor) getDescriptor().getValues().get(this.index);
            }

            public final Descriptors.EnumDescriptor getDescriptorForType() {
                return getDescriptor();
            }

            public static final Descriptors.EnumDescriptor getDescriptor() {
                return (Descriptors.EnumDescriptor) TwoWayChannelMessage.getDescriptor().getEnumTypes().get(0);
            }

            public static MessageType valueOf(Descriptors.EnumValueDescriptor enumValueDescriptor) {
                if (enumValueDescriptor.getType() != getDescriptor()) {
                    throw new IllegalArgumentException("EnumValueDescriptor is not for this type.");
                }
                return VALUES[enumValueDescriptor.getIndex()];
            }

            MessageType(int i, int i2) {
                this.index = i;
                this.value = i2;
            }
        }

        @Override
        public boolean hasType() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public MessageType getType() {
            return this.type_;
        }

        @Override
        public boolean hasClientVersion() {
            return (this.bitField0_ & 2) == 2;
        }

        @Override
        public ClientVersion getClientVersion() {
            return this.clientVersion_;
        }

        @Override
        public ClientVersionOrBuilder getClientVersionOrBuilder() {
            return this.clientVersion_;
        }

        @Override
        public boolean hasServerVersion() {
            return (this.bitField0_ & 4) == 4;
        }

        @Override
        public ServerVersion getServerVersion() {
            return this.serverVersion_;
        }

        @Override
        public ServerVersionOrBuilder getServerVersionOrBuilder() {
            return this.serverVersion_;
        }

        @Override
        public boolean hasInitiate() {
            return (this.bitField0_ & 8) == 8;
        }

        @Override
        public Initiate getInitiate() {
            return this.initiate_;
        }

        @Override
        public InitiateOrBuilder getInitiateOrBuilder() {
            return this.initiate_;
        }

        @Override
        public boolean hasProvideRefund() {
            return (this.bitField0_ & 16) == 16;
        }

        @Override
        public ProvideRefund getProvideRefund() {
            return this.provideRefund_;
        }

        @Override
        public ProvideRefundOrBuilder getProvideRefundOrBuilder() {
            return this.provideRefund_;
        }

        @Override
        public boolean hasReturnRefund() {
            return (this.bitField0_ & 32) == 32;
        }

        @Override
        public ReturnRefund getReturnRefund() {
            return this.returnRefund_;
        }

        @Override
        public ReturnRefundOrBuilder getReturnRefundOrBuilder() {
            return this.returnRefund_;
        }

        @Override
        public boolean hasProvideContract() {
            return (this.bitField0_ & 64) == 64;
        }

        @Override
        public ProvideContract getProvideContract() {
            return this.provideContract_;
        }

        @Override
        public ProvideContractOrBuilder getProvideContractOrBuilder() {
            return this.provideContract_;
        }

        @Override
        public boolean hasUpdatePayment() {
            return (this.bitField0_ & 128) == 128;
        }

        @Override
        public UpdatePayment getUpdatePayment() {
            return this.updatePayment_;
        }

        @Override
        public UpdatePaymentOrBuilder getUpdatePaymentOrBuilder() {
            return this.updatePayment_;
        }

        @Override
        public boolean hasPaymentAck() {
            return (this.bitField0_ & JSONParser.ACCEPT_TAILLING_DATA) == 256;
        }

        @Override
        public PaymentAck getPaymentAck() {
            return this.paymentAck_;
        }

        @Override
        public PaymentAckOrBuilder getPaymentAckOrBuilder() {
            return this.paymentAck_;
        }

        @Override
        public boolean hasSettlement() {
            return (this.bitField0_ & 512) == 512;
        }

        @Override
        public Settlement getSettlement() {
            return this.settlement_;
        }

        @Override
        public SettlementOrBuilder getSettlementOrBuilder() {
            return this.settlement_;
        }

        @Override
        public boolean hasError() {
            return (this.bitField0_ & 1024) == 1024;
        }

        @Override
        public Error getError() {
            return this.error_;
        }

        @Override
        public ErrorOrBuilder getErrorOrBuilder() {
            return this.error_;
        }

        private void initFields() {
            this.type_ = MessageType.CLIENT_VERSION;
            this.clientVersion_ = ClientVersion.getDefaultInstance();
            this.serverVersion_ = ServerVersion.getDefaultInstance();
            this.initiate_ = Initiate.getDefaultInstance();
            this.provideRefund_ = ProvideRefund.getDefaultInstance();
            this.returnRefund_ = ReturnRefund.getDefaultInstance();
            this.provideContract_ = ProvideContract.getDefaultInstance();
            this.updatePayment_ = UpdatePayment.getDefaultInstance();
            this.paymentAck_ = PaymentAck.getDefaultInstance();
            this.settlement_ = Settlement.getDefaultInstance();
            this.error_ = Error.getDefaultInstance();
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            if (!hasType()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (hasClientVersion() && !getClientVersion().isInitialized()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (hasServerVersion() && !getServerVersion().isInitialized()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (hasInitiate() && !getInitiate().isInitialized()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (hasProvideRefund() && !getProvideRefund().isInitialized()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (hasReturnRefund() && !getReturnRefund().isInitialized()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (hasProvideContract() && !getProvideContract().isInitialized()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (hasUpdatePayment() && !getUpdatePayment().isInitialized()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (hasSettlement() && !getSettlement().isInitialized()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeEnum(1, this.type_.getNumber());
            }
            if ((this.bitField0_ & 2) == 2) {
                codedOutputStream.writeMessage(2, this.clientVersion_);
            }
            if ((this.bitField0_ & 4) == 4) {
                codedOutputStream.writeMessage(3, this.serverVersion_);
            }
            if ((this.bitField0_ & 8) == 8) {
                codedOutputStream.writeMessage(4, this.initiate_);
            }
            if ((this.bitField0_ & 16) == 16) {
                codedOutputStream.writeMessage(5, this.provideRefund_);
            }
            if ((this.bitField0_ & 32) == 32) {
                codedOutputStream.writeMessage(6, this.returnRefund_);
            }
            if ((this.bitField0_ & 64) == 64) {
                codedOutputStream.writeMessage(7, this.provideContract_);
            }
            if ((this.bitField0_ & 128) == 128) {
                codedOutputStream.writeMessage(8, this.updatePayment_);
            }
            if ((this.bitField0_ & 512) == 512) {
                codedOutputStream.writeMessage(9, this.settlement_);
            }
            if ((this.bitField0_ & 1024) == 1024) {
                codedOutputStream.writeMessage(10, this.error_);
            }
            if ((this.bitField0_ & JSONParser.ACCEPT_TAILLING_DATA) == 256) {
                codedOutputStream.writeMessage(11, this.paymentAck_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeEnumSize = (this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeEnumSize(1, this.type_.getNumber()) : 0;
            if ((this.bitField0_ & 2) == 2) {
                computeEnumSize += CodedOutputStream.computeMessageSize(2, this.clientVersion_);
            }
            if ((this.bitField0_ & 4) == 4) {
                computeEnumSize += CodedOutputStream.computeMessageSize(3, this.serverVersion_);
            }
            if ((this.bitField0_ & 8) == 8) {
                computeEnumSize += CodedOutputStream.computeMessageSize(4, this.initiate_);
            }
            if ((this.bitField0_ & 16) == 16) {
                computeEnumSize += CodedOutputStream.computeMessageSize(5, this.provideRefund_);
            }
            if ((this.bitField0_ & 32) == 32) {
                computeEnumSize += CodedOutputStream.computeMessageSize(6, this.returnRefund_);
            }
            if ((this.bitField0_ & 64) == 64) {
                computeEnumSize += CodedOutputStream.computeMessageSize(7, this.provideContract_);
            }
            if ((this.bitField0_ & 128) == 128) {
                computeEnumSize += CodedOutputStream.computeMessageSize(8, this.updatePayment_);
            }
            if ((this.bitField0_ & 512) == 512) {
                computeEnumSize += CodedOutputStream.computeMessageSize(9, this.settlement_);
            }
            if ((this.bitField0_ & 1024) == 1024) {
                computeEnumSize += CodedOutputStream.computeMessageSize(10, this.error_);
            }
            if ((this.bitField0_ & JSONParser.ACCEPT_TAILLING_DATA) == 256) {
                computeEnumSize += CodedOutputStream.computeMessageSize(11, this.paymentAck_);
            }
            int serializedSize = computeEnumSize + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = serializedSize;
            return serializedSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static TwoWayChannelMessage parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (TwoWayChannelMessage) PARSER.parseFrom(byteString);
        }

        public static TwoWayChannelMessage parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (TwoWayChannelMessage) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static TwoWayChannelMessage parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (TwoWayChannelMessage) PARSER.parseFrom(bArr);
        }

        public static TwoWayChannelMessage parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (TwoWayChannelMessage) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static TwoWayChannelMessage parseFrom(InputStream inputStream) throws IOException {
            return (TwoWayChannelMessage) PARSER.parseFrom(inputStream);
        }

        public static TwoWayChannelMessage parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (TwoWayChannelMessage) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static TwoWayChannelMessage parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (TwoWayChannelMessage) PARSER.parseDelimitedFrom(inputStream);
        }

        public static TwoWayChannelMessage parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (TwoWayChannelMessage) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static TwoWayChannelMessage parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (TwoWayChannelMessage) PARSER.parseFrom(codedInputStream);
        }

        public static TwoWayChannelMessage parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (TwoWayChannelMessage) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1803newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(TwoWayChannelMessage twoWayChannelMessage) {
            return newBuilder().mergeFrom(twoWayChannelMessage);
        }

        public Builder m1806toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements TwoWayChannelMessageOrBuilder {
            private int bitField0_;
            private SingleFieldBuilder<ClientVersion, ClientVersion.Builder, ClientVersionOrBuilder> clientVersionBuilder_;
            private ClientVersion clientVersion_;
            private SingleFieldBuilder<Error, Error.Builder, ErrorOrBuilder> errorBuilder_;
            private Error error_;
            private SingleFieldBuilder<Initiate, Initiate.Builder, InitiateOrBuilder> initiateBuilder_;
            private Initiate initiate_;
            private SingleFieldBuilder<PaymentAck, PaymentAck.Builder, PaymentAckOrBuilder> paymentAckBuilder_;
            private PaymentAck paymentAck_;
            private SingleFieldBuilder<ProvideContract, ProvideContract.Builder, ProvideContractOrBuilder> provideContractBuilder_;
            private ProvideContract provideContract_;
            private SingleFieldBuilder<ProvideRefund, ProvideRefund.Builder, ProvideRefundOrBuilder> provideRefundBuilder_;
            private ProvideRefund provideRefund_;
            private SingleFieldBuilder<ReturnRefund, ReturnRefund.Builder, ReturnRefundOrBuilder> returnRefundBuilder_;
            private ReturnRefund returnRefund_;
            private SingleFieldBuilder<ServerVersion, ServerVersion.Builder, ServerVersionOrBuilder> serverVersionBuilder_;
            private ServerVersion serverVersion_;
            private SingleFieldBuilder<Settlement, Settlement.Builder, SettlementOrBuilder> settlementBuilder_;
            private Settlement settlement_;
            private MessageType type_;
            private SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> updatePaymentBuilder_;
            private UpdatePayment updatePayment_;

            public static final Descriptors.Descriptor getDescriptor() {
                return Protos.internal_static_paymentchannels_TwoWayChannelMessage_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return Protos.internal_static_paymentchannels_TwoWayChannelMessage_fieldAccessorTable.ensureFieldAccessorsInitialized(TwoWayChannelMessage.class, Builder.class);
            }

            private Builder() {
                this.type_ = MessageType.CLIENT_VERSION;
                this.clientVersion_ = ClientVersion.getDefaultInstance();
                this.serverVersion_ = ServerVersion.getDefaultInstance();
                this.initiate_ = Initiate.getDefaultInstance();
                this.provideRefund_ = ProvideRefund.getDefaultInstance();
                this.returnRefund_ = ReturnRefund.getDefaultInstance();
                this.provideContract_ = ProvideContract.getDefaultInstance();
                this.updatePayment_ = UpdatePayment.getDefaultInstance();
                this.paymentAck_ = PaymentAck.getDefaultInstance();
                this.settlement_ = Settlement.getDefaultInstance();
                this.error_ = Error.getDefaultInstance();
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.type_ = MessageType.CLIENT_VERSION;
                this.clientVersion_ = ClientVersion.getDefaultInstance();
                this.serverVersion_ = ServerVersion.getDefaultInstance();
                this.initiate_ = Initiate.getDefaultInstance();
                this.provideRefund_ = ProvideRefund.getDefaultInstance();
                this.returnRefund_ = ReturnRefund.getDefaultInstance();
                this.provideContract_ = ProvideContract.getDefaultInstance();
                this.updatePayment_ = UpdatePayment.getDefaultInstance();
                this.paymentAck_ = PaymentAck.getDefaultInstance();
                this.settlement_ = Settlement.getDefaultInstance();
                this.error_ = Error.getDefaultInstance();
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                if (TwoWayChannelMessage.alwaysUseFieldBuilders) {
                    getClientVersionFieldBuilder();
                    getServerVersionFieldBuilder();
                    getInitiateFieldBuilder();
                    getProvideRefundFieldBuilder();
                    getReturnRefundFieldBuilder();
                    getProvideContractFieldBuilder();
                    getUpdatePaymentFieldBuilder();
                    getPaymentAckFieldBuilder();
                    getSettlementFieldBuilder();
                    getErrorFieldBuilder();
                }
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1815clear() {
                super.clear();
                this.type_ = MessageType.CLIENT_VERSION;
                this.bitField0_ &= -2;
                SingleFieldBuilder<ClientVersion, ClientVersion.Builder, ClientVersionOrBuilder> singleFieldBuilder = this.clientVersionBuilder_;
                if (singleFieldBuilder == null) {
                    this.clientVersion_ = ClientVersion.getDefaultInstance();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -3;
                SingleFieldBuilder<ServerVersion, ServerVersion.Builder, ServerVersionOrBuilder> singleFieldBuilder2 = this.serverVersionBuilder_;
                if (singleFieldBuilder2 == null) {
                    this.serverVersion_ = ServerVersion.getDefaultInstance();
                } else {
                    singleFieldBuilder2.clear();
                }
                this.bitField0_ &= -5;
                SingleFieldBuilder<Initiate, Initiate.Builder, InitiateOrBuilder> singleFieldBuilder3 = this.initiateBuilder_;
                if (singleFieldBuilder3 == null) {
                    this.initiate_ = Initiate.getDefaultInstance();
                } else {
                    singleFieldBuilder3.clear();
                }
                this.bitField0_ &= -9;
                SingleFieldBuilder<ProvideRefund, ProvideRefund.Builder, ProvideRefundOrBuilder> singleFieldBuilder4 = this.provideRefundBuilder_;
                if (singleFieldBuilder4 == null) {
                    this.provideRefund_ = ProvideRefund.getDefaultInstance();
                } else {
                    singleFieldBuilder4.clear();
                }
                this.bitField0_ &= -17;
                SingleFieldBuilder<ReturnRefund, ReturnRefund.Builder, ReturnRefundOrBuilder> singleFieldBuilder5 = this.returnRefundBuilder_;
                if (singleFieldBuilder5 == null) {
                    this.returnRefund_ = ReturnRefund.getDefaultInstance();
                } else {
                    singleFieldBuilder5.clear();
                }
                this.bitField0_ &= -33;
                SingleFieldBuilder<ProvideContract, ProvideContract.Builder, ProvideContractOrBuilder> singleFieldBuilder6 = this.provideContractBuilder_;
                if (singleFieldBuilder6 == null) {
                    this.provideContract_ = ProvideContract.getDefaultInstance();
                } else {
                    singleFieldBuilder6.clear();
                }
                this.bitField0_ &= -65;
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder7 = this.updatePaymentBuilder_;
                if (singleFieldBuilder7 == null) {
                    this.updatePayment_ = UpdatePayment.getDefaultInstance();
                } else {
                    singleFieldBuilder7.clear();
                }
                this.bitField0_ &= -129;
                SingleFieldBuilder<PaymentAck, PaymentAck.Builder, PaymentAckOrBuilder> singleFieldBuilder8 = this.paymentAckBuilder_;
                if (singleFieldBuilder8 == null) {
                    this.paymentAck_ = PaymentAck.getDefaultInstance();
                } else {
                    singleFieldBuilder8.clear();
                }
                this.bitField0_ &= -257;
                SingleFieldBuilder<Settlement, Settlement.Builder, SettlementOrBuilder> singleFieldBuilder9 = this.settlementBuilder_;
                if (singleFieldBuilder9 == null) {
                    this.settlement_ = Settlement.getDefaultInstance();
                } else {
                    singleFieldBuilder9.clear();
                }
                this.bitField0_ &= -513;
                SingleFieldBuilder<Error, Error.Builder, ErrorOrBuilder> singleFieldBuilder10 = this.errorBuilder_;
                if (singleFieldBuilder10 == null) {
                    this.error_ = Error.getDefaultInstance();
                } else {
                    singleFieldBuilder10.clear();
                }
                this.bitField0_ &= -1025;
                return this;
            }

            public Builder m1821clone() {
                return create().mergeFrom(m1811buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return Protos.internal_static_paymentchannels_TwoWayChannelMessage_descriptor;
            }

            public TwoWayChannelMessage m1823getDefaultInstanceForType() {
                return TwoWayChannelMessage.getDefaultInstance();
            }

            public TwoWayChannelMessage m1809build() {
                TwoWayChannelMessage m1811buildPartial = m1811buildPartial();
                if (m1811buildPartial.isInitialized()) {
                    return m1811buildPartial;
                }
                throw newUninitializedMessageException(m1811buildPartial);
            }

            public TwoWayChannelMessage m1811buildPartial() {
                TwoWayChannelMessage twoWayChannelMessage = new TwoWayChannelMessage(this);
                int i = this.bitField0_;
                int i2 = (i & 1) != 1 ? 0 : 1;
                twoWayChannelMessage.type_ = this.type_;
                if ((i & 2) == 2) {
                    i2 |= 2;
                }
                SingleFieldBuilder<ClientVersion, ClientVersion.Builder, ClientVersionOrBuilder> singleFieldBuilder = this.clientVersionBuilder_;
                if (singleFieldBuilder == null) {
                    twoWayChannelMessage.clientVersion_ = this.clientVersion_;
                } else {
                    twoWayChannelMessage.clientVersion_ = (ClientVersion) singleFieldBuilder.build();
                }
                if ((i & 4) == 4) {
                    i2 |= 4;
                }
                SingleFieldBuilder<ServerVersion, ServerVersion.Builder, ServerVersionOrBuilder> singleFieldBuilder2 = this.serverVersionBuilder_;
                if (singleFieldBuilder2 == null) {
                    twoWayChannelMessage.serverVersion_ = this.serverVersion_;
                } else {
                    twoWayChannelMessage.serverVersion_ = (ServerVersion) singleFieldBuilder2.build();
                }
                if ((i & 8) == 8) {
                    i2 |= 8;
                }
                SingleFieldBuilder<Initiate, Initiate.Builder, InitiateOrBuilder> singleFieldBuilder3 = this.initiateBuilder_;
                if (singleFieldBuilder3 == null) {
                    twoWayChannelMessage.initiate_ = this.initiate_;
                } else {
                    twoWayChannelMessage.initiate_ = (Initiate) singleFieldBuilder3.build();
                }
                if ((i & 16) == 16) {
                    i2 |= 16;
                }
                SingleFieldBuilder<ProvideRefund, ProvideRefund.Builder, ProvideRefundOrBuilder> singleFieldBuilder4 = this.provideRefundBuilder_;
                if (singleFieldBuilder4 == null) {
                    twoWayChannelMessage.provideRefund_ = this.provideRefund_;
                } else {
                    twoWayChannelMessage.provideRefund_ = (ProvideRefund) singleFieldBuilder4.build();
                }
                if ((i & 32) == 32) {
                    i2 |= 32;
                }
                SingleFieldBuilder<ReturnRefund, ReturnRefund.Builder, ReturnRefundOrBuilder> singleFieldBuilder5 = this.returnRefundBuilder_;
                if (singleFieldBuilder5 == null) {
                    twoWayChannelMessage.returnRefund_ = this.returnRefund_;
                } else {
                    twoWayChannelMessage.returnRefund_ = (ReturnRefund) singleFieldBuilder5.build();
                }
                if ((i & 64) == 64) {
                    i2 |= 64;
                }
                SingleFieldBuilder<ProvideContract, ProvideContract.Builder, ProvideContractOrBuilder> singleFieldBuilder6 = this.provideContractBuilder_;
                if (singleFieldBuilder6 == null) {
                    twoWayChannelMessage.provideContract_ = this.provideContract_;
                } else {
                    twoWayChannelMessage.provideContract_ = (ProvideContract) singleFieldBuilder6.build();
                }
                if ((i & 128) == 128) {
                    i2 |= 128;
                }
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder7 = this.updatePaymentBuilder_;
                if (singleFieldBuilder7 == null) {
                    twoWayChannelMessage.updatePayment_ = this.updatePayment_;
                } else {
                    twoWayChannelMessage.updatePayment_ = (UpdatePayment) singleFieldBuilder7.build();
                }
                if ((i & JSONParser.ACCEPT_TAILLING_DATA) == 256) {
                    i2 |= JSONParser.ACCEPT_TAILLING_DATA;
                }
                SingleFieldBuilder<PaymentAck, PaymentAck.Builder, PaymentAckOrBuilder> singleFieldBuilder8 = this.paymentAckBuilder_;
                if (singleFieldBuilder8 == null) {
                    twoWayChannelMessage.paymentAck_ = this.paymentAck_;
                } else {
                    twoWayChannelMessage.paymentAck_ = (PaymentAck) singleFieldBuilder8.build();
                }
                if ((i & 512) == 512) {
                    i2 |= 512;
                }
                SingleFieldBuilder<Settlement, Settlement.Builder, SettlementOrBuilder> singleFieldBuilder9 = this.settlementBuilder_;
                if (singleFieldBuilder9 == null) {
                    twoWayChannelMessage.settlement_ = this.settlement_;
                } else {
                    twoWayChannelMessage.settlement_ = (Settlement) singleFieldBuilder9.build();
                }
                if ((i & 1024) == 1024) {
                    i2 |= 1024;
                }
                SingleFieldBuilder<Error, Error.Builder, ErrorOrBuilder> singleFieldBuilder10 = this.errorBuilder_;
                if (singleFieldBuilder10 == null) {
                    twoWayChannelMessage.error_ = this.error_;
                } else {
                    twoWayChannelMessage.error_ = (Error) singleFieldBuilder10.build();
                }
                twoWayChannelMessage.bitField0_ = i2;
                onBuilt();
                return twoWayChannelMessage;
            }

            public Builder m1827mergeFrom(Message message) {
                if (message instanceof TwoWayChannelMessage) {
                    return mergeFrom((TwoWayChannelMessage) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(TwoWayChannelMessage twoWayChannelMessage) {
                if (twoWayChannelMessage == TwoWayChannelMessage.getDefaultInstance()) {
                    return this;
                }
                if (twoWayChannelMessage.hasType()) {
                    setType(twoWayChannelMessage.getType());
                }
                if (twoWayChannelMessage.hasClientVersion()) {
                    mergeClientVersion(twoWayChannelMessage.getClientVersion());
                }
                if (twoWayChannelMessage.hasServerVersion()) {
                    mergeServerVersion(twoWayChannelMessage.getServerVersion());
                }
                if (twoWayChannelMessage.hasInitiate()) {
                    mergeInitiate(twoWayChannelMessage.getInitiate());
                }
                if (twoWayChannelMessage.hasProvideRefund()) {
                    mergeProvideRefund(twoWayChannelMessage.getProvideRefund());
                }
                if (twoWayChannelMessage.hasReturnRefund()) {
                    mergeReturnRefund(twoWayChannelMessage.getReturnRefund());
                }
                if (twoWayChannelMessage.hasProvideContract()) {
                    mergeProvideContract(twoWayChannelMessage.getProvideContract());
                }
                if (twoWayChannelMessage.hasUpdatePayment()) {
                    mergeUpdatePayment(twoWayChannelMessage.getUpdatePayment());
                }
                if (twoWayChannelMessage.hasPaymentAck()) {
                    mergePaymentAck(twoWayChannelMessage.getPaymentAck());
                }
                if (twoWayChannelMessage.hasSettlement()) {
                    mergeSettlement(twoWayChannelMessage.getSettlement());
                }
                if (twoWayChannelMessage.hasError()) {
                    mergeError(twoWayChannelMessage.getError());
                }
                mergeUnknownFields(twoWayChannelMessage.getUnknownFields());
                return this;
            }

            public final boolean isInitialized() {
                if (!hasType()) {
                    return false;
                }
                if (hasClientVersion() && !getClientVersion().isInitialized()) {
                    return false;
                }
                if (hasServerVersion() && !getServerVersion().isInitialized()) {
                    return false;
                }
                if (hasInitiate() && !getInitiate().isInitialized()) {
                    return false;
                }
                if (hasProvideRefund() && !getProvideRefund().isInitialized()) {
                    return false;
                }
                if (hasReturnRefund() && !getReturnRefund().isInitialized()) {
                    return false;
                }
                if (hasProvideContract() && !getProvideContract().isInitialized()) {
                    return false;
                }
                if (!hasUpdatePayment() || getUpdatePayment().isInitialized()) {
                    return !hasSettlement() || getSettlement().isInitialized();
                }
                return false;
            }

            public org.bitcoin.paymentchannel.Protos.TwoWayChannelMessage.Builder m1828mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.paymentchannel.Protos.TwoWayChannelMessage.Builder.m1828mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.paymentchannel.Protos$TwoWayChannelMessage$Builder");
            }

            @Override
            public boolean hasType() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public MessageType getType() {
                return this.type_;
            }

            public Builder setType(MessageType messageType) {
                if (messageType == null) {
                    throw null;
                }
                this.bitField0_ |= 1;
                this.type_ = messageType;
                onChanged();
                return this;
            }

            public Builder clearType() {
                this.bitField0_ &= -2;
                this.type_ = MessageType.CLIENT_VERSION;
                onChanged();
                return this;
            }

            @Override
            public boolean hasClientVersion() {
                return (this.bitField0_ & 2) == 2;
            }

            @Override
            public ClientVersion getClientVersion() {
                SingleFieldBuilder<ClientVersion, ClientVersion.Builder, ClientVersionOrBuilder> singleFieldBuilder = this.clientVersionBuilder_;
                if (singleFieldBuilder == null) {
                    return this.clientVersion_;
                }
                return (ClientVersion) singleFieldBuilder.getMessage();
            }

            public Builder setClientVersion(ClientVersion clientVersion) {
                SingleFieldBuilder<ClientVersion, ClientVersion.Builder, ClientVersionOrBuilder> singleFieldBuilder = this.clientVersionBuilder_;
                if (singleFieldBuilder != null) {
                    singleFieldBuilder.setMessage(clientVersion);
                } else {
                    if (clientVersion == null) {
                        throw null;
                    }
                    this.clientVersion_ = clientVersion;
                    onChanged();
                }
                this.bitField0_ |= 2;
                return this;
            }

            public Builder setClientVersion(ClientVersion.Builder builder) {
                SingleFieldBuilder<ClientVersion, ClientVersion.Builder, ClientVersionOrBuilder> singleFieldBuilder = this.clientVersionBuilder_;
                if (singleFieldBuilder == null) {
                    this.clientVersion_ = builder.m1538build();
                    onChanged();
                } else {
                    singleFieldBuilder.setMessage(builder.m1538build());
                }
                this.bitField0_ |= 2;
                return this;
            }

            public Builder mergeClientVersion(ClientVersion clientVersion) {
                SingleFieldBuilder<ClientVersion, ClientVersion.Builder, ClientVersionOrBuilder> singleFieldBuilder = this.clientVersionBuilder_;
                if (singleFieldBuilder == null) {
                    if ((this.bitField0_ & 2) == 2 && this.clientVersion_ != ClientVersion.getDefaultInstance()) {
                        this.clientVersion_ = ClientVersion.newBuilder(this.clientVersion_).mergeFrom(clientVersion).m1540buildPartial();
                    } else {
                        this.clientVersion_ = clientVersion;
                    }
                    onChanged();
                } else {
                    singleFieldBuilder.mergeFrom(clientVersion);
                }
                this.bitField0_ |= 2;
                return this;
            }

            public Builder clearClientVersion() {
                SingleFieldBuilder<ClientVersion, ClientVersion.Builder, ClientVersionOrBuilder> singleFieldBuilder = this.clientVersionBuilder_;
                if (singleFieldBuilder == null) {
                    this.clientVersion_ = ClientVersion.getDefaultInstance();
                    onChanged();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -3;
                return this;
            }

            public ClientVersion.Builder getClientVersionBuilder() {
                this.bitField0_ |= 2;
                onChanged();
                return (ClientVersion.Builder) getClientVersionFieldBuilder().getBuilder();
            }

            @Override
            public ClientVersionOrBuilder getClientVersionOrBuilder() {
                SingleFieldBuilder<ClientVersion, ClientVersion.Builder, ClientVersionOrBuilder> singleFieldBuilder = this.clientVersionBuilder_;
                if (singleFieldBuilder != null) {
                    return (ClientVersionOrBuilder) singleFieldBuilder.getMessageOrBuilder();
                }
                return this.clientVersion_;
            }

            private SingleFieldBuilder<ClientVersion, ClientVersion.Builder, ClientVersionOrBuilder> getClientVersionFieldBuilder() {
                if (this.clientVersionBuilder_ == null) {
                    this.clientVersionBuilder_ = new SingleFieldBuilder<>(getClientVersion(), getParentForChildren(), isClean());
                    this.clientVersion_ = null;
                }
                return this.clientVersionBuilder_;
            }

            @Override
            public boolean hasServerVersion() {
                return (this.bitField0_ & 4) == 4;
            }

            @Override
            public ServerVersion getServerVersion() {
                SingleFieldBuilder<ServerVersion, ServerVersion.Builder, ServerVersionOrBuilder> singleFieldBuilder = this.serverVersionBuilder_;
                if (singleFieldBuilder == null) {
                    return this.serverVersion_;
                }
                return (ServerVersion) singleFieldBuilder.getMessage();
            }

            public Builder setServerVersion(ServerVersion serverVersion) {
                SingleFieldBuilder<ServerVersion, ServerVersion.Builder, ServerVersionOrBuilder> singleFieldBuilder = this.serverVersionBuilder_;
                if (singleFieldBuilder != null) {
                    singleFieldBuilder.setMessage(serverVersion);
                } else {
                    if (serverVersion == null) {
                        throw null;
                    }
                    this.serverVersion_ = serverVersion;
                    onChanged();
                }
                this.bitField0_ |= 4;
                return this;
            }

            public Builder setServerVersion(ServerVersion.Builder builder) {
                SingleFieldBuilder<ServerVersion, ServerVersion.Builder, ServerVersionOrBuilder> singleFieldBuilder = this.serverVersionBuilder_;
                if (singleFieldBuilder == null) {
                    this.serverVersion_ = builder.m1749build();
                    onChanged();
                } else {
                    singleFieldBuilder.setMessage(builder.m1749build());
                }
                this.bitField0_ |= 4;
                return this;
            }

            public Builder mergeServerVersion(ServerVersion serverVersion) {
                SingleFieldBuilder<ServerVersion, ServerVersion.Builder, ServerVersionOrBuilder> singleFieldBuilder = this.serverVersionBuilder_;
                if (singleFieldBuilder == null) {
                    if ((this.bitField0_ & 4) == 4 && this.serverVersion_ != ServerVersion.getDefaultInstance()) {
                        this.serverVersion_ = ServerVersion.newBuilder(this.serverVersion_).mergeFrom(serverVersion).m1751buildPartial();
                    } else {
                        this.serverVersion_ = serverVersion;
                    }
                    onChanged();
                } else {
                    singleFieldBuilder.mergeFrom(serverVersion);
                }
                this.bitField0_ |= 4;
                return this;
            }

            public Builder clearServerVersion() {
                SingleFieldBuilder<ServerVersion, ServerVersion.Builder, ServerVersionOrBuilder> singleFieldBuilder = this.serverVersionBuilder_;
                if (singleFieldBuilder == null) {
                    this.serverVersion_ = ServerVersion.getDefaultInstance();
                    onChanged();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -5;
                return this;
            }

            public ServerVersion.Builder getServerVersionBuilder() {
                this.bitField0_ |= 4;
                onChanged();
                return (ServerVersion.Builder) getServerVersionFieldBuilder().getBuilder();
            }

            @Override
            public ServerVersionOrBuilder getServerVersionOrBuilder() {
                SingleFieldBuilder<ServerVersion, ServerVersion.Builder, ServerVersionOrBuilder> singleFieldBuilder = this.serverVersionBuilder_;
                if (singleFieldBuilder != null) {
                    return (ServerVersionOrBuilder) singleFieldBuilder.getMessageOrBuilder();
                }
                return this.serverVersion_;
            }

            private SingleFieldBuilder<ServerVersion, ServerVersion.Builder, ServerVersionOrBuilder> getServerVersionFieldBuilder() {
                if (this.serverVersionBuilder_ == null) {
                    this.serverVersionBuilder_ = new SingleFieldBuilder<>(getServerVersion(), getParentForChildren(), isClean());
                    this.serverVersion_ = null;
                }
                return this.serverVersionBuilder_;
            }

            @Override
            public boolean hasInitiate() {
                return (this.bitField0_ & 8) == 8;
            }

            @Override
            public Initiate getInitiate() {
                SingleFieldBuilder<Initiate, Initiate.Builder, InitiateOrBuilder> singleFieldBuilder = this.initiateBuilder_;
                if (singleFieldBuilder == null) {
                    return this.initiate_;
                }
                return (Initiate) singleFieldBuilder.getMessage();
            }

            public Builder setInitiate(Initiate initiate) {
                SingleFieldBuilder<Initiate, Initiate.Builder, InitiateOrBuilder> singleFieldBuilder = this.initiateBuilder_;
                if (singleFieldBuilder != null) {
                    singleFieldBuilder.setMessage(initiate);
                } else {
                    if (initiate == null) {
                        throw null;
                    }
                    this.initiate_ = initiate;
                    onChanged();
                }
                this.bitField0_ |= 8;
                return this;
            }

            public Builder setInitiate(Initiate.Builder builder) {
                SingleFieldBuilder<Initiate, Initiate.Builder, InitiateOrBuilder> singleFieldBuilder = this.initiateBuilder_;
                if (singleFieldBuilder == null) {
                    this.initiate_ = builder.m1599build();
                    onChanged();
                } else {
                    singleFieldBuilder.setMessage(builder.m1599build());
                }
                this.bitField0_ |= 8;
                return this;
            }

            public Builder mergeInitiate(Initiate initiate) {
                SingleFieldBuilder<Initiate, Initiate.Builder, InitiateOrBuilder> singleFieldBuilder = this.initiateBuilder_;
                if (singleFieldBuilder == null) {
                    if ((this.bitField0_ & 8) == 8 && this.initiate_ != Initiate.getDefaultInstance()) {
                        this.initiate_ = Initiate.newBuilder(this.initiate_).mergeFrom(initiate).m1601buildPartial();
                    } else {
                        this.initiate_ = initiate;
                    }
                    onChanged();
                } else {
                    singleFieldBuilder.mergeFrom(initiate);
                }
                this.bitField0_ |= 8;
                return this;
            }

            public Builder clearInitiate() {
                SingleFieldBuilder<Initiate, Initiate.Builder, InitiateOrBuilder> singleFieldBuilder = this.initiateBuilder_;
                if (singleFieldBuilder == null) {
                    this.initiate_ = Initiate.getDefaultInstance();
                    onChanged();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -9;
                return this;
            }

            public Initiate.Builder getInitiateBuilder() {
                this.bitField0_ |= 8;
                onChanged();
                return (Initiate.Builder) getInitiateFieldBuilder().getBuilder();
            }

            @Override
            public InitiateOrBuilder getInitiateOrBuilder() {
                SingleFieldBuilder<Initiate, Initiate.Builder, InitiateOrBuilder> singleFieldBuilder = this.initiateBuilder_;
                if (singleFieldBuilder != null) {
                    return (InitiateOrBuilder) singleFieldBuilder.getMessageOrBuilder();
                }
                return this.initiate_;
            }

            private SingleFieldBuilder<Initiate, Initiate.Builder, InitiateOrBuilder> getInitiateFieldBuilder() {
                if (this.initiateBuilder_ == null) {
                    this.initiateBuilder_ = new SingleFieldBuilder<>(getInitiate(), getParentForChildren(), isClean());
                    this.initiate_ = null;
                }
                return this.initiateBuilder_;
            }

            @Override
            public boolean hasProvideRefund() {
                return (this.bitField0_ & 16) == 16;
            }

            @Override
            public ProvideRefund getProvideRefund() {
                SingleFieldBuilder<ProvideRefund, ProvideRefund.Builder, ProvideRefundOrBuilder> singleFieldBuilder = this.provideRefundBuilder_;
                if (singleFieldBuilder == null) {
                    return this.provideRefund_;
                }
                return (ProvideRefund) singleFieldBuilder.getMessage();
            }

            public Builder setProvideRefund(ProvideRefund provideRefund) {
                SingleFieldBuilder<ProvideRefund, ProvideRefund.Builder, ProvideRefundOrBuilder> singleFieldBuilder = this.provideRefundBuilder_;
                if (singleFieldBuilder != null) {
                    singleFieldBuilder.setMessage(provideRefund);
                } else {
                    if (provideRefund == null) {
                        throw null;
                    }
                    this.provideRefund_ = provideRefund;
                    onChanged();
                }
                this.bitField0_ |= 16;
                return this;
            }

            public Builder setProvideRefund(ProvideRefund.Builder builder) {
                SingleFieldBuilder<ProvideRefund, ProvideRefund.Builder, ProvideRefundOrBuilder> singleFieldBuilder = this.provideRefundBuilder_;
                if (singleFieldBuilder == null) {
                    this.provideRefund_ = builder.m1689build();
                    onChanged();
                } else {
                    singleFieldBuilder.setMessage(builder.m1689build());
                }
                this.bitField0_ |= 16;
                return this;
            }

            public Builder mergeProvideRefund(ProvideRefund provideRefund) {
                SingleFieldBuilder<ProvideRefund, ProvideRefund.Builder, ProvideRefundOrBuilder> singleFieldBuilder = this.provideRefundBuilder_;
                if (singleFieldBuilder == null) {
                    if ((this.bitField0_ & 16) == 16 && this.provideRefund_ != ProvideRefund.getDefaultInstance()) {
                        this.provideRefund_ = ProvideRefund.newBuilder(this.provideRefund_).mergeFrom(provideRefund).m1691buildPartial();
                    } else {
                        this.provideRefund_ = provideRefund;
                    }
                    onChanged();
                } else {
                    singleFieldBuilder.mergeFrom(provideRefund);
                }
                this.bitField0_ |= 16;
                return this;
            }

            public Builder clearProvideRefund() {
                SingleFieldBuilder<ProvideRefund, ProvideRefund.Builder, ProvideRefundOrBuilder> singleFieldBuilder = this.provideRefundBuilder_;
                if (singleFieldBuilder == null) {
                    this.provideRefund_ = ProvideRefund.getDefaultInstance();
                    onChanged();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -17;
                return this;
            }

            public ProvideRefund.Builder getProvideRefundBuilder() {
                this.bitField0_ |= 16;
                onChanged();
                return (ProvideRefund.Builder) getProvideRefundFieldBuilder().getBuilder();
            }

            @Override
            public ProvideRefundOrBuilder getProvideRefundOrBuilder() {
                SingleFieldBuilder<ProvideRefund, ProvideRefund.Builder, ProvideRefundOrBuilder> singleFieldBuilder = this.provideRefundBuilder_;
                if (singleFieldBuilder != null) {
                    return (ProvideRefundOrBuilder) singleFieldBuilder.getMessageOrBuilder();
                }
                return this.provideRefund_;
            }

            private SingleFieldBuilder<ProvideRefund, ProvideRefund.Builder, ProvideRefundOrBuilder> getProvideRefundFieldBuilder() {
                if (this.provideRefundBuilder_ == null) {
                    this.provideRefundBuilder_ = new SingleFieldBuilder<>(getProvideRefund(), getParentForChildren(), isClean());
                    this.provideRefund_ = null;
                }
                return this.provideRefundBuilder_;
            }

            @Override
            public boolean hasReturnRefund() {
                return (this.bitField0_ & 32) == 32;
            }

            @Override
            public ReturnRefund getReturnRefund() {
                SingleFieldBuilder<ReturnRefund, ReturnRefund.Builder, ReturnRefundOrBuilder> singleFieldBuilder = this.returnRefundBuilder_;
                if (singleFieldBuilder == null) {
                    return this.returnRefund_;
                }
                return (ReturnRefund) singleFieldBuilder.getMessage();
            }

            public Builder setReturnRefund(ReturnRefund returnRefund) {
                SingleFieldBuilder<ReturnRefund, ReturnRefund.Builder, ReturnRefundOrBuilder> singleFieldBuilder = this.returnRefundBuilder_;
                if (singleFieldBuilder != null) {
                    singleFieldBuilder.setMessage(returnRefund);
                } else {
                    if (returnRefund == null) {
                        throw null;
                    }
                    this.returnRefund_ = returnRefund;
                    onChanged();
                }
                this.bitField0_ |= 32;
                return this;
            }

            public Builder setReturnRefund(ReturnRefund.Builder builder) {
                SingleFieldBuilder<ReturnRefund, ReturnRefund.Builder, ReturnRefundOrBuilder> singleFieldBuilder = this.returnRefundBuilder_;
                if (singleFieldBuilder == null) {
                    this.returnRefund_ = builder.m1719build();
                    onChanged();
                } else {
                    singleFieldBuilder.setMessage(builder.m1719build());
                }
                this.bitField0_ |= 32;
                return this;
            }

            public Builder mergeReturnRefund(ReturnRefund returnRefund) {
                SingleFieldBuilder<ReturnRefund, ReturnRefund.Builder, ReturnRefundOrBuilder> singleFieldBuilder = this.returnRefundBuilder_;
                if (singleFieldBuilder == null) {
                    if ((this.bitField0_ & 32) == 32 && this.returnRefund_ != ReturnRefund.getDefaultInstance()) {
                        this.returnRefund_ = ReturnRefund.newBuilder(this.returnRefund_).mergeFrom(returnRefund).m1721buildPartial();
                    } else {
                        this.returnRefund_ = returnRefund;
                    }
                    onChanged();
                } else {
                    singleFieldBuilder.mergeFrom(returnRefund);
                }
                this.bitField0_ |= 32;
                return this;
            }

            public Builder clearReturnRefund() {
                SingleFieldBuilder<ReturnRefund, ReturnRefund.Builder, ReturnRefundOrBuilder> singleFieldBuilder = this.returnRefundBuilder_;
                if (singleFieldBuilder == null) {
                    this.returnRefund_ = ReturnRefund.getDefaultInstance();
                    onChanged();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -33;
                return this;
            }

            public ReturnRefund.Builder getReturnRefundBuilder() {
                this.bitField0_ |= 32;
                onChanged();
                return (ReturnRefund.Builder) getReturnRefundFieldBuilder().getBuilder();
            }

            @Override
            public ReturnRefundOrBuilder getReturnRefundOrBuilder() {
                SingleFieldBuilder<ReturnRefund, ReturnRefund.Builder, ReturnRefundOrBuilder> singleFieldBuilder = this.returnRefundBuilder_;
                if (singleFieldBuilder != null) {
                    return (ReturnRefundOrBuilder) singleFieldBuilder.getMessageOrBuilder();
                }
                return this.returnRefund_;
            }

            private SingleFieldBuilder<ReturnRefund, ReturnRefund.Builder, ReturnRefundOrBuilder> getReturnRefundFieldBuilder() {
                if (this.returnRefundBuilder_ == null) {
                    this.returnRefundBuilder_ = new SingleFieldBuilder<>(getReturnRefund(), getParentForChildren(), isClean());
                    this.returnRefund_ = null;
                }
                return this.returnRefundBuilder_;
            }

            @Override
            public boolean hasProvideContract() {
                return (this.bitField0_ & 64) == 64;
            }

            @Override
            public ProvideContract getProvideContract() {
                SingleFieldBuilder<ProvideContract, ProvideContract.Builder, ProvideContractOrBuilder> singleFieldBuilder = this.provideContractBuilder_;
                if (singleFieldBuilder == null) {
                    return this.provideContract_;
                }
                return (ProvideContract) singleFieldBuilder.getMessage();
            }

            public Builder setProvideContract(ProvideContract provideContract) {
                SingleFieldBuilder<ProvideContract, ProvideContract.Builder, ProvideContractOrBuilder> singleFieldBuilder = this.provideContractBuilder_;
                if (singleFieldBuilder != null) {
                    singleFieldBuilder.setMessage(provideContract);
                } else {
                    if (provideContract == null) {
                        throw null;
                    }
                    this.provideContract_ = provideContract;
                    onChanged();
                }
                this.bitField0_ |= 64;
                return this;
            }

            public Builder setProvideContract(ProvideContract.Builder builder) {
                SingleFieldBuilder<ProvideContract, ProvideContract.Builder, ProvideContractOrBuilder> singleFieldBuilder = this.provideContractBuilder_;
                if (singleFieldBuilder == null) {
                    this.provideContract_ = builder.m1659build();
                    onChanged();
                } else {
                    singleFieldBuilder.setMessage(builder.m1659build());
                }
                this.bitField0_ |= 64;
                return this;
            }

            public Builder mergeProvideContract(ProvideContract provideContract) {
                SingleFieldBuilder<ProvideContract, ProvideContract.Builder, ProvideContractOrBuilder> singleFieldBuilder = this.provideContractBuilder_;
                if (singleFieldBuilder == null) {
                    if ((this.bitField0_ & 64) == 64 && this.provideContract_ != ProvideContract.getDefaultInstance()) {
                        this.provideContract_ = ProvideContract.newBuilder(this.provideContract_).mergeFrom(provideContract).m1661buildPartial();
                    } else {
                        this.provideContract_ = provideContract;
                    }
                    onChanged();
                } else {
                    singleFieldBuilder.mergeFrom(provideContract);
                }
                this.bitField0_ |= 64;
                return this;
            }

            public Builder clearProvideContract() {
                SingleFieldBuilder<ProvideContract, ProvideContract.Builder, ProvideContractOrBuilder> singleFieldBuilder = this.provideContractBuilder_;
                if (singleFieldBuilder == null) {
                    this.provideContract_ = ProvideContract.getDefaultInstance();
                    onChanged();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -65;
                return this;
            }

            public ProvideContract.Builder getProvideContractBuilder() {
                this.bitField0_ |= 64;
                onChanged();
                return (ProvideContract.Builder) getProvideContractFieldBuilder().getBuilder();
            }

            @Override
            public ProvideContractOrBuilder getProvideContractOrBuilder() {
                SingleFieldBuilder<ProvideContract, ProvideContract.Builder, ProvideContractOrBuilder> singleFieldBuilder = this.provideContractBuilder_;
                if (singleFieldBuilder != null) {
                    return (ProvideContractOrBuilder) singleFieldBuilder.getMessageOrBuilder();
                }
                return this.provideContract_;
            }

            private SingleFieldBuilder<ProvideContract, ProvideContract.Builder, ProvideContractOrBuilder> getProvideContractFieldBuilder() {
                if (this.provideContractBuilder_ == null) {
                    this.provideContractBuilder_ = new SingleFieldBuilder<>(getProvideContract(), getParentForChildren(), isClean());
                    this.provideContract_ = null;
                }
                return this.provideContractBuilder_;
            }

            @Override
            public boolean hasUpdatePayment() {
                return (this.bitField0_ & 128) == 128;
            }

            @Override
            public UpdatePayment getUpdatePayment() {
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.updatePaymentBuilder_;
                if (singleFieldBuilder == null) {
                    return this.updatePayment_;
                }
                return (UpdatePayment) singleFieldBuilder.getMessage();
            }

            public Builder setUpdatePayment(UpdatePayment updatePayment) {
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.updatePaymentBuilder_;
                if (singleFieldBuilder != null) {
                    singleFieldBuilder.setMessage(updatePayment);
                } else {
                    if (updatePayment == null) {
                        throw null;
                    }
                    this.updatePayment_ = updatePayment;
                    onChanged();
                }
                this.bitField0_ |= 128;
                return this;
            }

            public Builder setUpdatePayment(UpdatePayment.Builder builder) {
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.updatePaymentBuilder_;
                if (singleFieldBuilder == null) {
                    this.updatePayment_ = builder.m1840build();
                    onChanged();
                } else {
                    singleFieldBuilder.setMessage(builder.m1840build());
                }
                this.bitField0_ |= 128;
                return this;
            }

            public Builder mergeUpdatePayment(UpdatePayment updatePayment) {
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.updatePaymentBuilder_;
                if (singleFieldBuilder == null) {
                    if ((this.bitField0_ & 128) == 128 && this.updatePayment_ != UpdatePayment.getDefaultInstance()) {
                        this.updatePayment_ = UpdatePayment.newBuilder(this.updatePayment_).mergeFrom(updatePayment).m1842buildPartial();
                    } else {
                        this.updatePayment_ = updatePayment;
                    }
                    onChanged();
                } else {
                    singleFieldBuilder.mergeFrom(updatePayment);
                }
                this.bitField0_ |= 128;
                return this;
            }

            public Builder clearUpdatePayment() {
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.updatePaymentBuilder_;
                if (singleFieldBuilder == null) {
                    this.updatePayment_ = UpdatePayment.getDefaultInstance();
                    onChanged();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -129;
                return this;
            }

            public UpdatePayment.Builder getUpdatePaymentBuilder() {
                this.bitField0_ |= 128;
                onChanged();
                return (UpdatePayment.Builder) getUpdatePaymentFieldBuilder().getBuilder();
            }

            @Override
            public UpdatePaymentOrBuilder getUpdatePaymentOrBuilder() {
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.updatePaymentBuilder_;
                if (singleFieldBuilder != null) {
                    return (UpdatePaymentOrBuilder) singleFieldBuilder.getMessageOrBuilder();
                }
                return this.updatePayment_;
            }

            private SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> getUpdatePaymentFieldBuilder() {
                if (this.updatePaymentBuilder_ == null) {
                    this.updatePaymentBuilder_ = new SingleFieldBuilder<>(getUpdatePayment(), getParentForChildren(), isClean());
                    this.updatePayment_ = null;
                }
                return this.updatePaymentBuilder_;
            }

            @Override
            public boolean hasPaymentAck() {
                return (this.bitField0_ & JSONParser.ACCEPT_TAILLING_DATA) == 256;
            }

            @Override
            public PaymentAck getPaymentAck() {
                SingleFieldBuilder<PaymentAck, PaymentAck.Builder, PaymentAckOrBuilder> singleFieldBuilder = this.paymentAckBuilder_;
                if (singleFieldBuilder == null) {
                    return this.paymentAck_;
                }
                return (PaymentAck) singleFieldBuilder.getMessage();
            }

            public Builder setPaymentAck(PaymentAck paymentAck) {
                SingleFieldBuilder<PaymentAck, PaymentAck.Builder, PaymentAckOrBuilder> singleFieldBuilder = this.paymentAckBuilder_;
                if (singleFieldBuilder != null) {
                    singleFieldBuilder.setMessage(paymentAck);
                } else {
                    if (paymentAck == null) {
                        throw null;
                    }
                    this.paymentAck_ = paymentAck;
                    onChanged();
                }
                this.bitField0_ |= JSONParser.ACCEPT_TAILLING_DATA;
                return this;
            }

            public Builder setPaymentAck(PaymentAck.Builder builder) {
                SingleFieldBuilder<PaymentAck, PaymentAck.Builder, PaymentAckOrBuilder> singleFieldBuilder = this.paymentAckBuilder_;
                if (singleFieldBuilder == null) {
                    this.paymentAck_ = builder.m1629build();
                    onChanged();
                } else {
                    singleFieldBuilder.setMessage(builder.m1629build());
                }
                this.bitField0_ |= JSONParser.ACCEPT_TAILLING_DATA;
                return this;
            }

            public Builder mergePaymentAck(PaymentAck paymentAck) {
                SingleFieldBuilder<PaymentAck, PaymentAck.Builder, PaymentAckOrBuilder> singleFieldBuilder = this.paymentAckBuilder_;
                if (singleFieldBuilder == null) {
                    if ((this.bitField0_ & JSONParser.ACCEPT_TAILLING_DATA) == 256 && this.paymentAck_ != PaymentAck.getDefaultInstance()) {
                        this.paymentAck_ = PaymentAck.newBuilder(this.paymentAck_).mergeFrom(paymentAck).m1631buildPartial();
                    } else {
                        this.paymentAck_ = paymentAck;
                    }
                    onChanged();
                } else {
                    singleFieldBuilder.mergeFrom(paymentAck);
                }
                this.bitField0_ |= JSONParser.ACCEPT_TAILLING_DATA;
                return this;
            }

            public Builder clearPaymentAck() {
                SingleFieldBuilder<PaymentAck, PaymentAck.Builder, PaymentAckOrBuilder> singleFieldBuilder = this.paymentAckBuilder_;
                if (singleFieldBuilder == null) {
                    this.paymentAck_ = PaymentAck.getDefaultInstance();
                    onChanged();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -257;
                return this;
            }

            public PaymentAck.Builder getPaymentAckBuilder() {
                this.bitField0_ |= JSONParser.ACCEPT_TAILLING_DATA;
                onChanged();
                return (PaymentAck.Builder) getPaymentAckFieldBuilder().getBuilder();
            }

            @Override
            public PaymentAckOrBuilder getPaymentAckOrBuilder() {
                SingleFieldBuilder<PaymentAck, PaymentAck.Builder, PaymentAckOrBuilder> singleFieldBuilder = this.paymentAckBuilder_;
                if (singleFieldBuilder != null) {
                    return (PaymentAckOrBuilder) singleFieldBuilder.getMessageOrBuilder();
                }
                return this.paymentAck_;
            }

            private SingleFieldBuilder<PaymentAck, PaymentAck.Builder, PaymentAckOrBuilder> getPaymentAckFieldBuilder() {
                if (this.paymentAckBuilder_ == null) {
                    this.paymentAckBuilder_ = new SingleFieldBuilder<>(getPaymentAck(), getParentForChildren(), isClean());
                    this.paymentAck_ = null;
                }
                return this.paymentAckBuilder_;
            }

            @Override
            public boolean hasSettlement() {
                return (this.bitField0_ & 512) == 512;
            }

            @Override
            public Settlement getSettlement() {
                SingleFieldBuilder<Settlement, Settlement.Builder, SettlementOrBuilder> singleFieldBuilder = this.settlementBuilder_;
                if (singleFieldBuilder == null) {
                    return this.settlement_;
                }
                return (Settlement) singleFieldBuilder.getMessage();
            }

            public Builder setSettlement(Settlement settlement) {
                SingleFieldBuilder<Settlement, Settlement.Builder, SettlementOrBuilder> singleFieldBuilder = this.settlementBuilder_;
                if (singleFieldBuilder != null) {
                    singleFieldBuilder.setMessage(settlement);
                } else {
                    if (settlement == null) {
                        throw null;
                    }
                    this.settlement_ = settlement;
                    onChanged();
                }
                this.bitField0_ |= 512;
                return this;
            }

            public Builder setSettlement(Settlement.Builder builder) {
                SingleFieldBuilder<Settlement, Settlement.Builder, SettlementOrBuilder> singleFieldBuilder = this.settlementBuilder_;
                if (singleFieldBuilder == null) {
                    this.settlement_ = builder.m1779build();
                    onChanged();
                } else {
                    singleFieldBuilder.setMessage(builder.m1779build());
                }
                this.bitField0_ |= 512;
                return this;
            }

            public Builder mergeSettlement(Settlement settlement) {
                SingleFieldBuilder<Settlement, Settlement.Builder, SettlementOrBuilder> singleFieldBuilder = this.settlementBuilder_;
                if (singleFieldBuilder == null) {
                    if ((this.bitField0_ & 512) == 512 && this.settlement_ != Settlement.getDefaultInstance()) {
                        this.settlement_ = Settlement.newBuilder(this.settlement_).mergeFrom(settlement).m1781buildPartial();
                    } else {
                        this.settlement_ = settlement;
                    }
                    onChanged();
                } else {
                    singleFieldBuilder.mergeFrom(settlement);
                }
                this.bitField0_ |= 512;
                return this;
            }

            public Builder clearSettlement() {
                SingleFieldBuilder<Settlement, Settlement.Builder, SettlementOrBuilder> singleFieldBuilder = this.settlementBuilder_;
                if (singleFieldBuilder == null) {
                    this.settlement_ = Settlement.getDefaultInstance();
                    onChanged();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -513;
                return this;
            }

            public Settlement.Builder getSettlementBuilder() {
                this.bitField0_ |= 512;
                onChanged();
                return (Settlement.Builder) getSettlementFieldBuilder().getBuilder();
            }

            @Override
            public SettlementOrBuilder getSettlementOrBuilder() {
                SingleFieldBuilder<Settlement, Settlement.Builder, SettlementOrBuilder> singleFieldBuilder = this.settlementBuilder_;
                if (singleFieldBuilder != null) {
                    return (SettlementOrBuilder) singleFieldBuilder.getMessageOrBuilder();
                }
                return this.settlement_;
            }

            private SingleFieldBuilder<Settlement, Settlement.Builder, SettlementOrBuilder> getSettlementFieldBuilder() {
                if (this.settlementBuilder_ == null) {
                    this.settlementBuilder_ = new SingleFieldBuilder<>(getSettlement(), getParentForChildren(), isClean());
                    this.settlement_ = null;
                }
                return this.settlementBuilder_;
            }

            @Override
            public boolean hasError() {
                return (this.bitField0_ & 1024) == 1024;
            }

            @Override
            public Error getError() {
                SingleFieldBuilder<Error, Error.Builder, ErrorOrBuilder> singleFieldBuilder = this.errorBuilder_;
                if (singleFieldBuilder == null) {
                    return this.error_;
                }
                return (Error) singleFieldBuilder.getMessage();
            }

            public Builder setError(Error error) {
                SingleFieldBuilder<Error, Error.Builder, ErrorOrBuilder> singleFieldBuilder = this.errorBuilder_;
                if (singleFieldBuilder != null) {
                    singleFieldBuilder.setMessage(error);
                } else {
                    if (error == null) {
                        throw null;
                    }
                    this.error_ = error;
                    onChanged();
                }
                this.bitField0_ |= 1024;
                return this;
            }

            public Builder setError(Error.Builder builder) {
                SingleFieldBuilder<Error, Error.Builder, ErrorOrBuilder> singleFieldBuilder = this.errorBuilder_;
                if (singleFieldBuilder == null) {
                    this.error_ = builder.m1568build();
                    onChanged();
                } else {
                    singleFieldBuilder.setMessage(builder.m1568build());
                }
                this.bitField0_ |= 1024;
                return this;
            }

            public Builder mergeError(Error error) {
                SingleFieldBuilder<Error, Error.Builder, ErrorOrBuilder> singleFieldBuilder = this.errorBuilder_;
                if (singleFieldBuilder == null) {
                    if ((this.bitField0_ & 1024) == 1024 && this.error_ != Error.getDefaultInstance()) {
                        this.error_ = Error.newBuilder(this.error_).mergeFrom(error).m1570buildPartial();
                    } else {
                        this.error_ = error;
                    }
                    onChanged();
                } else {
                    singleFieldBuilder.mergeFrom(error);
                }
                this.bitField0_ |= 1024;
                return this;
            }

            public Builder clearError() {
                SingleFieldBuilder<Error, Error.Builder, ErrorOrBuilder> singleFieldBuilder = this.errorBuilder_;
                if (singleFieldBuilder == null) {
                    this.error_ = Error.getDefaultInstance();
                    onChanged();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -1025;
                return this;
            }

            public Error.Builder getErrorBuilder() {
                this.bitField0_ |= 1024;
                onChanged();
                return (Error.Builder) getErrorFieldBuilder().getBuilder();
            }

            @Override
            public ErrorOrBuilder getErrorOrBuilder() {
                SingleFieldBuilder<Error, Error.Builder, ErrorOrBuilder> singleFieldBuilder = this.errorBuilder_;
                if (singleFieldBuilder != null) {
                    return (ErrorOrBuilder) singleFieldBuilder.getMessageOrBuilder();
                }
                return this.error_;
            }

            private SingleFieldBuilder<Error, Error.Builder, ErrorOrBuilder> getErrorFieldBuilder() {
                if (this.errorBuilder_ == null) {
                    this.errorBuilder_ = new SingleFieldBuilder<>(getError(), getParentForChildren(), isClean());
                    this.error_ = null;
                }
                return this.errorBuilder_;
            }
        }
    }

    public static final class ClientVersion extends GeneratedMessage implements ClientVersionOrBuilder {
        public static final int MAJOR_FIELD_NUMBER = 1;
        public static final int MINOR_FIELD_NUMBER = 2;
        public static Parser<ClientVersion> PARSER = new AbstractParser<ClientVersion>() {
            public ClientVersion parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new ClientVersion(codedInputStream, extensionRegistryLite);
            }
        };
        public static final int PREVIOUS_CHANNEL_CONTRACT_HASH_FIELD_NUMBER = 3;
        public static final int TIME_WINDOW_SECS_FIELD_NUMBER = 4;
        private static final ClientVersion defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private int major_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private int minor_;
        private ByteString previousChannelContractHash_;
        private long timeWindowSecs_;
        private final UnknownFieldSet unknownFields;

        private ClientVersion(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private ClientVersion(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static ClientVersion getDefaultInstance() {
            return defaultInstance;
        }

        public ClientVersion m1530getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private ClientVersion(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        int readTag = codedInputStream.readTag();
                        if (readTag != 0) {
                            if (readTag == 8) {
                                this.bitField0_ |= 1;
                                this.major_ = codedInputStream.readInt32();
                            } else if (readTag == 16) {
                                this.bitField0_ |= 2;
                                this.minor_ = codedInputStream.readInt32();
                            } else if (readTag == 26) {
                                this.bitField0_ |= 4;
                                this.previousChannelContractHash_ = codedInputStream.readBytes();
                            } else if (readTag != 32) {
                                if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                }
                            } else {
                                this.bitField0_ |= 8;
                                this.timeWindowSecs_ = codedInputStream.readUInt64();
                            }
                        }
                        z = true;
                    } catch (InvalidProtocolBufferException e) {
                        throw e.setUnfinishedMessage(this);
                    } catch (IOException e2) {
                        throw new InvalidProtocolBufferException(e2.getMessage()).setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return Protos.internal_static_paymentchannels_ClientVersion_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return Protos.internal_static_paymentchannels_ClientVersion_fieldAccessorTable.ensureFieldAccessorsInitialized(ClientVersion.class, Builder.class);
        }

        static {
            ClientVersion clientVersion = new ClientVersion(true);
            defaultInstance = clientVersion;
            clientVersion.initFields();
        }

        public Parser<ClientVersion> getParserForType() {
            return PARSER;
        }

        @Override
        public boolean hasMajor() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public int getMajor() {
            return this.major_;
        }

        @Override
        public boolean hasMinor() {
            return (this.bitField0_ & 2) == 2;
        }

        @Override
        public int getMinor() {
            return this.minor_;
        }

        @Override
        public boolean hasPreviousChannelContractHash() {
            return (this.bitField0_ & 4) == 4;
        }

        @Override
        public ByteString getPreviousChannelContractHash() {
            return this.previousChannelContractHash_;
        }

        @Override
        public boolean hasTimeWindowSecs() {
            return (this.bitField0_ & 8) == 8;
        }

        @Override
        public long getTimeWindowSecs() {
            return this.timeWindowSecs_;
        }

        private void initFields() {
            this.major_ = 0;
            this.minor_ = 0;
            this.previousChannelContractHash_ = ByteString.EMPTY;
            this.timeWindowSecs_ = PaymentChannelClient.DEFAULT_TIME_WINDOW;
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            if (!hasMajor()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeInt32(1, this.major_);
            }
            if ((this.bitField0_ & 2) == 2) {
                codedOutputStream.writeInt32(2, this.minor_);
            }
            if ((this.bitField0_ & 4) == 4) {
                codedOutputStream.writeBytes(3, this.previousChannelContractHash_);
            }
            if ((this.bitField0_ & 8) == 8) {
                codedOutputStream.writeUInt64(4, this.timeWindowSecs_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeInt32Size = (this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeInt32Size(1, this.major_) : 0;
            if ((this.bitField0_ & 2) == 2) {
                computeInt32Size += CodedOutputStream.computeInt32Size(2, this.minor_);
            }
            if ((this.bitField0_ & 4) == 4) {
                computeInt32Size += CodedOutputStream.computeBytesSize(3, this.previousChannelContractHash_);
            }
            if ((this.bitField0_ & 8) == 8) {
                computeInt32Size += CodedOutputStream.computeUInt64Size(4, this.timeWindowSecs_);
            }
            int serializedSize = computeInt32Size + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = serializedSize;
            return serializedSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static ClientVersion parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (ClientVersion) PARSER.parseFrom(byteString);
        }

        public static ClientVersion parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (ClientVersion) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static ClientVersion parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (ClientVersion) PARSER.parseFrom(bArr);
        }

        public static ClientVersion parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (ClientVersion) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static ClientVersion parseFrom(InputStream inputStream) throws IOException {
            return (ClientVersion) PARSER.parseFrom(inputStream);
        }

        public static ClientVersion parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ClientVersion) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static ClientVersion parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (ClientVersion) PARSER.parseDelimitedFrom(inputStream);
        }

        public static ClientVersion parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ClientVersion) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static ClientVersion parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (ClientVersion) PARSER.parseFrom(codedInputStream);
        }

        public static ClientVersion parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ClientVersion) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1532newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(ClientVersion clientVersion) {
            return newBuilder().mergeFrom(clientVersion);
        }

        public Builder m1535toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements ClientVersionOrBuilder {
            private int bitField0_;
            private int major_;
            private int minor_;
            private ByteString previousChannelContractHash_;
            private long timeWindowSecs_;

            public static final Descriptors.Descriptor getDescriptor() {
                return Protos.internal_static_paymentchannels_ClientVersion_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return Protos.internal_static_paymentchannels_ClientVersion_fieldAccessorTable.ensureFieldAccessorsInitialized(ClientVersion.class, Builder.class);
            }

            private Builder() {
                this.previousChannelContractHash_ = ByteString.EMPTY;
                this.timeWindowSecs_ = PaymentChannelClient.DEFAULT_TIME_WINDOW;
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.previousChannelContractHash_ = ByteString.EMPTY;
                this.timeWindowSecs_ = PaymentChannelClient.DEFAULT_TIME_WINDOW;
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                boolean unused = ClientVersion.alwaysUseFieldBuilders;
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1544clear() {
                super.clear();
                this.major_ = 0;
                int i = this.bitField0_ & (-2);
                this.bitField0_ = i;
                this.minor_ = 0;
                this.bitField0_ = i & (-3);
                this.previousChannelContractHash_ = ByteString.EMPTY;
                int i2 = this.bitField0_ & (-5);
                this.bitField0_ = i2;
                this.timeWindowSecs_ = PaymentChannelClient.DEFAULT_TIME_WINDOW;
                this.bitField0_ = i2 & (-9);
                return this;
            }

            public Builder m1550clone() {
                return create().mergeFrom(m1540buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return Protos.internal_static_paymentchannels_ClientVersion_descriptor;
            }

            public ClientVersion m1552getDefaultInstanceForType() {
                return ClientVersion.getDefaultInstance();
            }

            public ClientVersion m1538build() {
                ClientVersion m1540buildPartial = m1540buildPartial();
                if (m1540buildPartial.isInitialized()) {
                    return m1540buildPartial;
                }
                throw newUninitializedMessageException(m1540buildPartial);
            }

            public ClientVersion m1540buildPartial() {
                ClientVersion clientVersion = new ClientVersion(this);
                int i = this.bitField0_;
                int i2 = (i & 1) != 1 ? 0 : 1;
                clientVersion.major_ = this.major_;
                if ((i & 2) == 2) {
                    i2 |= 2;
                }
                clientVersion.minor_ = this.minor_;
                if ((i & 4) == 4) {
                    i2 |= 4;
                }
                clientVersion.previousChannelContractHash_ = this.previousChannelContractHash_;
                if ((i & 8) == 8) {
                    i2 |= 8;
                }
                clientVersion.timeWindowSecs_ = this.timeWindowSecs_;
                clientVersion.bitField0_ = i2;
                onBuilt();
                return clientVersion;
            }

            public Builder m1556mergeFrom(Message message) {
                if (message instanceof ClientVersion) {
                    return mergeFrom((ClientVersion) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(ClientVersion clientVersion) {
                if (clientVersion == ClientVersion.getDefaultInstance()) {
                    return this;
                }
                if (clientVersion.hasMajor()) {
                    setMajor(clientVersion.getMajor());
                }
                if (clientVersion.hasMinor()) {
                    setMinor(clientVersion.getMinor());
                }
                if (clientVersion.hasPreviousChannelContractHash()) {
                    setPreviousChannelContractHash(clientVersion.getPreviousChannelContractHash());
                }
                if (clientVersion.hasTimeWindowSecs()) {
                    setTimeWindowSecs(clientVersion.getTimeWindowSecs());
                }
                mergeUnknownFields(clientVersion.getUnknownFields());
                return this;
            }

            public final boolean isInitialized() {
                return hasMajor();
            }

            public org.bitcoin.paymentchannel.Protos.ClientVersion.Builder m1557mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.paymentchannel.Protos.ClientVersion.Builder.m1557mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.paymentchannel.Protos$ClientVersion$Builder");
            }

            @Override
            public boolean hasMajor() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public int getMajor() {
                return this.major_;
            }

            public Builder setMajor(int i) {
                this.bitField0_ |= 1;
                this.major_ = i;
                onChanged();
                return this;
            }

            public Builder clearMajor() {
                this.bitField0_ &= -2;
                this.major_ = 0;
                onChanged();
                return this;
            }

            @Override
            public boolean hasMinor() {
                return (this.bitField0_ & 2) == 2;
            }

            @Override
            public int getMinor() {
                return this.minor_;
            }

            public Builder setMinor(int i) {
                this.bitField0_ |= 2;
                this.minor_ = i;
                onChanged();
                return this;
            }

            public Builder clearMinor() {
                this.bitField0_ &= -3;
                this.minor_ = 0;
                onChanged();
                return this;
            }

            @Override
            public boolean hasPreviousChannelContractHash() {
                return (this.bitField0_ & 4) == 4;
            }

            @Override
            public ByteString getPreviousChannelContractHash() {
                return this.previousChannelContractHash_;
            }

            public Builder setPreviousChannelContractHash(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 4;
                this.previousChannelContractHash_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearPreviousChannelContractHash() {
                this.bitField0_ &= -5;
                this.previousChannelContractHash_ = ClientVersion.getDefaultInstance().getPreviousChannelContractHash();
                onChanged();
                return this;
            }

            @Override
            public boolean hasTimeWindowSecs() {
                return (this.bitField0_ & 8) == 8;
            }

            @Override
            public long getTimeWindowSecs() {
                return this.timeWindowSecs_;
            }

            public Builder setTimeWindowSecs(long j) {
                this.bitField0_ |= 8;
                this.timeWindowSecs_ = j;
                onChanged();
                return this;
            }

            public Builder clearTimeWindowSecs() {
                this.bitField0_ &= -9;
                this.timeWindowSecs_ = PaymentChannelClient.DEFAULT_TIME_WINDOW;
                onChanged();
                return this;
            }
        }
    }

    public static final class ServerVersion extends GeneratedMessage implements ServerVersionOrBuilder {
        public static final int MAJOR_FIELD_NUMBER = 1;
        public static final int MINOR_FIELD_NUMBER = 2;
        public static Parser<ServerVersion> PARSER = new AbstractParser<ServerVersion>() {
            public ServerVersion parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new ServerVersion(codedInputStream, extensionRegistryLite);
            }
        };
        private static final ServerVersion defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private int major_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private int minor_;
        private final UnknownFieldSet unknownFields;

        private ServerVersion(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private ServerVersion(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static ServerVersion getDefaultInstance() {
            return defaultInstance;
        }

        public ServerVersion m1741getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private ServerVersion(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        try {
                            int readTag = codedInputStream.readTag();
                            if (readTag != 0) {
                                if (readTag == 8) {
                                    this.bitField0_ |= 1;
                                    this.major_ = codedInputStream.readInt32();
                                } else if (readTag != 16) {
                                    if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                    }
                                } else {
                                    this.bitField0_ |= 2;
                                    this.minor_ = codedInputStream.readInt32();
                                }
                            }
                            z = true;
                        } catch (IOException e) {
                            throw new InvalidProtocolBufferException(e.getMessage()).setUnfinishedMessage(this);
                        }
                    } catch (InvalidProtocolBufferException e2) {
                        throw e2.setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return Protos.internal_static_paymentchannels_ServerVersion_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return Protos.internal_static_paymentchannels_ServerVersion_fieldAccessorTable.ensureFieldAccessorsInitialized(ServerVersion.class, Builder.class);
        }

        static {
            ServerVersion serverVersion = new ServerVersion(true);
            defaultInstance = serverVersion;
            serverVersion.initFields();
        }

        public Parser<ServerVersion> getParserForType() {
            return PARSER;
        }

        @Override
        public boolean hasMajor() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public int getMajor() {
            return this.major_;
        }

        @Override
        public boolean hasMinor() {
            return (this.bitField0_ & 2) == 2;
        }

        @Override
        public int getMinor() {
            return this.minor_;
        }

        private void initFields() {
            this.major_ = 0;
            this.minor_ = 0;
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            if (!hasMajor()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeInt32(1, this.major_);
            }
            if ((this.bitField0_ & 2) == 2) {
                codedOutputStream.writeInt32(2, this.minor_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeInt32Size = (this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeInt32Size(1, this.major_) : 0;
            if ((this.bitField0_ & 2) == 2) {
                computeInt32Size += CodedOutputStream.computeInt32Size(2, this.minor_);
            }
            int serializedSize = computeInt32Size + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = serializedSize;
            return serializedSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static ServerVersion parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (ServerVersion) PARSER.parseFrom(byteString);
        }

        public static ServerVersion parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (ServerVersion) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static ServerVersion parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (ServerVersion) PARSER.parseFrom(bArr);
        }

        public static ServerVersion parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (ServerVersion) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static ServerVersion parseFrom(InputStream inputStream) throws IOException {
            return (ServerVersion) PARSER.parseFrom(inputStream);
        }

        public static ServerVersion parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ServerVersion) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static ServerVersion parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (ServerVersion) PARSER.parseDelimitedFrom(inputStream);
        }

        public static ServerVersion parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ServerVersion) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static ServerVersion parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (ServerVersion) PARSER.parseFrom(codedInputStream);
        }

        public static ServerVersion parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ServerVersion) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1743newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(ServerVersion serverVersion) {
            return newBuilder().mergeFrom(serverVersion);
        }

        public Builder m1746toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements ServerVersionOrBuilder {
            private int bitField0_;
            private int major_;
            private int minor_;

            public static final Descriptors.Descriptor getDescriptor() {
                return Protos.internal_static_paymentchannels_ServerVersion_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return Protos.internal_static_paymentchannels_ServerVersion_fieldAccessorTable.ensureFieldAccessorsInitialized(ServerVersion.class, Builder.class);
            }

            private Builder() {
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                boolean unused = ServerVersion.alwaysUseFieldBuilders;
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1755clear() {
                super.clear();
                this.major_ = 0;
                int i = this.bitField0_ & (-2);
                this.bitField0_ = i;
                this.minor_ = 0;
                this.bitField0_ = i & (-3);
                return this;
            }

            public Builder m1761clone() {
                return create().mergeFrom(m1751buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return Protos.internal_static_paymentchannels_ServerVersion_descriptor;
            }

            public ServerVersion m1763getDefaultInstanceForType() {
                return ServerVersion.getDefaultInstance();
            }

            public ServerVersion m1749build() {
                ServerVersion m1751buildPartial = m1751buildPartial();
                if (m1751buildPartial.isInitialized()) {
                    return m1751buildPartial;
                }
                throw newUninitializedMessageException(m1751buildPartial);
            }

            public ServerVersion m1751buildPartial() {
                ServerVersion serverVersion = new ServerVersion(this);
                int i = this.bitField0_;
                int i2 = (i & 1) != 1 ? 0 : 1;
                serverVersion.major_ = this.major_;
                if ((i & 2) == 2) {
                    i2 |= 2;
                }
                serverVersion.minor_ = this.minor_;
                serverVersion.bitField0_ = i2;
                onBuilt();
                return serverVersion;
            }

            public Builder m1767mergeFrom(Message message) {
                if (message instanceof ServerVersion) {
                    return mergeFrom((ServerVersion) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(ServerVersion serverVersion) {
                if (serverVersion == ServerVersion.getDefaultInstance()) {
                    return this;
                }
                if (serverVersion.hasMajor()) {
                    setMajor(serverVersion.getMajor());
                }
                if (serverVersion.hasMinor()) {
                    setMinor(serverVersion.getMinor());
                }
                mergeUnknownFields(serverVersion.getUnknownFields());
                return this;
            }

            public final boolean isInitialized() {
                return hasMajor();
            }

            public org.bitcoin.paymentchannel.Protos.ServerVersion.Builder m1768mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.paymentchannel.Protos.ServerVersion.Builder.m1768mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.paymentchannel.Protos$ServerVersion$Builder");
            }

            @Override
            public boolean hasMajor() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public int getMajor() {
                return this.major_;
            }

            public Builder setMajor(int i) {
                this.bitField0_ |= 1;
                this.major_ = i;
                onChanged();
                return this;
            }

            public Builder clearMajor() {
                this.bitField0_ &= -2;
                this.major_ = 0;
                onChanged();
                return this;
            }

            @Override
            public boolean hasMinor() {
                return (this.bitField0_ & 2) == 2;
            }

            @Override
            public int getMinor() {
                return this.minor_;
            }

            public Builder setMinor(int i) {
                this.bitField0_ |= 2;
                this.minor_ = i;
                onChanged();
                return this;
            }

            public Builder clearMinor() {
                this.bitField0_ &= -3;
                this.minor_ = 0;
                onChanged();
                return this;
            }
        }
    }

    public static final class Initiate extends GeneratedMessage implements InitiateOrBuilder {
        public static final int EXPIRE_TIME_SECS_FIELD_NUMBER = 3;
        public static final int MIN_ACCEPTED_CHANNEL_SIZE_FIELD_NUMBER = 2;
        public static final int MIN_PAYMENT_FIELD_NUMBER = 4;
        public static final int MULTISIG_KEY_FIELD_NUMBER = 1;
        public static Parser<Initiate> PARSER = new AbstractParser<Initiate>() {
            public Initiate parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new Initiate(codedInputStream, extensionRegistryLite);
            }
        };
        private static final Initiate defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private long expireTimeSecs_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private long minAcceptedChannelSize_;
        private long minPayment_;
        private ByteString multisigKey_;
        private final UnknownFieldSet unknownFields;

        private Initiate(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private Initiate(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static Initiate getDefaultInstance() {
            return defaultInstance;
        }

        public Initiate m1591getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private Initiate(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        int readTag = codedInputStream.readTag();
                        if (readTag != 0) {
                            if (readTag == 10) {
                                this.bitField0_ |= 1;
                                this.multisigKey_ = codedInputStream.readBytes();
                            } else if (readTag == 16) {
                                this.bitField0_ |= 2;
                                this.minAcceptedChannelSize_ = codedInputStream.readUInt64();
                            } else if (readTag == 24) {
                                this.bitField0_ |= 4;
                                this.expireTimeSecs_ = codedInputStream.readUInt64();
                            } else if (readTag != 32) {
                                if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                }
                            } else {
                                this.bitField0_ |= 8;
                                this.minPayment_ = codedInputStream.readUInt64();
                            }
                        }
                        z = true;
                    } catch (InvalidProtocolBufferException e) {
                        throw e.setUnfinishedMessage(this);
                    } catch (IOException e2) {
                        throw new InvalidProtocolBufferException(e2.getMessage()).setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return Protos.internal_static_paymentchannels_Initiate_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return Protos.internal_static_paymentchannels_Initiate_fieldAccessorTable.ensureFieldAccessorsInitialized(Initiate.class, Builder.class);
        }

        static {
            Initiate initiate = new Initiate(true);
            defaultInstance = initiate;
            initiate.initFields();
        }

        public Parser<Initiate> getParserForType() {
            return PARSER;
        }

        @Override
        public boolean hasMultisigKey() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public ByteString getMultisigKey() {
            return this.multisigKey_;
        }

        @Override
        public boolean hasMinAcceptedChannelSize() {
            return (this.bitField0_ & 2) == 2;
        }

        @Override
        public long getMinAcceptedChannelSize() {
            return this.minAcceptedChannelSize_;
        }

        @Override
        public boolean hasExpireTimeSecs() {
            return (this.bitField0_ & 4) == 4;
        }

        @Override
        public long getExpireTimeSecs() {
            return this.expireTimeSecs_;
        }

        @Override
        public boolean hasMinPayment() {
            return (this.bitField0_ & 8) == 8;
        }

        @Override
        public long getMinPayment() {
            return this.minPayment_;
        }

        private void initFields() {
            this.multisigKey_ = ByteString.EMPTY;
            this.minAcceptedChannelSize_ = 0L;
            this.expireTimeSecs_ = 0L;
            this.minPayment_ = 0L;
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            if (!hasMultisigKey()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (!hasMinAcceptedChannelSize()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (!hasExpireTimeSecs()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (!hasMinPayment()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeBytes(1, this.multisigKey_);
            }
            if ((this.bitField0_ & 2) == 2) {
                codedOutputStream.writeUInt64(2, this.minAcceptedChannelSize_);
            }
            if ((this.bitField0_ & 4) == 4) {
                codedOutputStream.writeUInt64(3, this.expireTimeSecs_);
            }
            if ((this.bitField0_ & 8) == 8) {
                codedOutputStream.writeUInt64(4, this.minPayment_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeBytesSize = (this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeBytesSize(1, this.multisigKey_) : 0;
            if ((this.bitField0_ & 2) == 2) {
                computeBytesSize += CodedOutputStream.computeUInt64Size(2, this.minAcceptedChannelSize_);
            }
            if ((this.bitField0_ & 4) == 4) {
                computeBytesSize += CodedOutputStream.computeUInt64Size(3, this.expireTimeSecs_);
            }
            if ((this.bitField0_ & 8) == 8) {
                computeBytesSize += CodedOutputStream.computeUInt64Size(4, this.minPayment_);
            }
            int serializedSize = computeBytesSize + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = serializedSize;
            return serializedSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static Initiate parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (Initiate) PARSER.parseFrom(byteString);
        }

        public static Initiate parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (Initiate) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static Initiate parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (Initiate) PARSER.parseFrom(bArr);
        }

        public static Initiate parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (Initiate) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static Initiate parseFrom(InputStream inputStream) throws IOException {
            return (Initiate) PARSER.parseFrom(inputStream);
        }

        public static Initiate parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (Initiate) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static Initiate parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (Initiate) PARSER.parseDelimitedFrom(inputStream);
        }

        public static Initiate parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (Initiate) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static Initiate parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (Initiate) PARSER.parseFrom(codedInputStream);
        }

        public static Initiate parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (Initiate) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1593newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(Initiate initiate) {
            return newBuilder().mergeFrom(initiate);
        }

        public Builder m1596toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements InitiateOrBuilder {
            private int bitField0_;
            private long expireTimeSecs_;
            private long minAcceptedChannelSize_;
            private long minPayment_;
            private ByteString multisigKey_;

            public static final Descriptors.Descriptor getDescriptor() {
                return Protos.internal_static_paymentchannels_Initiate_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return Protos.internal_static_paymentchannels_Initiate_fieldAccessorTable.ensureFieldAccessorsInitialized(Initiate.class, Builder.class);
            }

            private Builder() {
                this.multisigKey_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.multisigKey_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                boolean unused = Initiate.alwaysUseFieldBuilders;
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1605clear() {
                super.clear();
                this.multisigKey_ = ByteString.EMPTY;
                int i = this.bitField0_ & (-2);
                this.bitField0_ = i;
                this.minAcceptedChannelSize_ = 0L;
                int i2 = i & (-3);
                this.bitField0_ = i2;
                this.expireTimeSecs_ = 0L;
                int i3 = i2 & (-5);
                this.bitField0_ = i3;
                this.minPayment_ = 0L;
                this.bitField0_ = i3 & (-9);
                return this;
            }

            public Builder m1611clone() {
                return create().mergeFrom(m1601buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return Protos.internal_static_paymentchannels_Initiate_descriptor;
            }

            public Initiate m1613getDefaultInstanceForType() {
                return Initiate.getDefaultInstance();
            }

            public Initiate m1599build() {
                Initiate m1601buildPartial = m1601buildPartial();
                if (m1601buildPartial.isInitialized()) {
                    return m1601buildPartial;
                }
                throw newUninitializedMessageException(m1601buildPartial);
            }

            public Initiate m1601buildPartial() {
                Initiate initiate = new Initiate(this);
                int i = this.bitField0_;
                int i2 = (i & 1) != 1 ? 0 : 1;
                initiate.multisigKey_ = this.multisigKey_;
                if ((i & 2) == 2) {
                    i2 |= 2;
                }
                initiate.minAcceptedChannelSize_ = this.minAcceptedChannelSize_;
                if ((i & 4) == 4) {
                    i2 |= 4;
                }
                initiate.expireTimeSecs_ = this.expireTimeSecs_;
                if ((i & 8) == 8) {
                    i2 |= 8;
                }
                initiate.minPayment_ = this.minPayment_;
                initiate.bitField0_ = i2;
                onBuilt();
                return initiate;
            }

            public Builder m1617mergeFrom(Message message) {
                if (message instanceof Initiate) {
                    return mergeFrom((Initiate) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(Initiate initiate) {
                if (initiate == Initiate.getDefaultInstance()) {
                    return this;
                }
                if (initiate.hasMultisigKey()) {
                    setMultisigKey(initiate.getMultisigKey());
                }
                if (initiate.hasMinAcceptedChannelSize()) {
                    setMinAcceptedChannelSize(initiate.getMinAcceptedChannelSize());
                }
                if (initiate.hasExpireTimeSecs()) {
                    setExpireTimeSecs(initiate.getExpireTimeSecs());
                }
                if (initiate.hasMinPayment()) {
                    setMinPayment(initiate.getMinPayment());
                }
                mergeUnknownFields(initiate.getUnknownFields());
                return this;
            }

            public final boolean isInitialized() {
                return hasMultisigKey() && hasMinAcceptedChannelSize() && hasExpireTimeSecs() && hasMinPayment();
            }

            public org.bitcoin.paymentchannel.Protos.Initiate.Builder m1618mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.paymentchannel.Protos.Initiate.Builder.m1618mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.paymentchannel.Protos$Initiate$Builder");
            }

            @Override
            public boolean hasMultisigKey() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public ByteString getMultisigKey() {
                return this.multisigKey_;
            }

            public Builder setMultisigKey(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 1;
                this.multisigKey_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearMultisigKey() {
                this.bitField0_ &= -2;
                this.multisigKey_ = Initiate.getDefaultInstance().getMultisigKey();
                onChanged();
                return this;
            }

            @Override
            public boolean hasMinAcceptedChannelSize() {
                return (this.bitField0_ & 2) == 2;
            }

            @Override
            public long getMinAcceptedChannelSize() {
                return this.minAcceptedChannelSize_;
            }

            public Builder setMinAcceptedChannelSize(long j) {
                this.bitField0_ |= 2;
                this.minAcceptedChannelSize_ = j;
                onChanged();
                return this;
            }

            public Builder clearMinAcceptedChannelSize() {
                this.bitField0_ &= -3;
                this.minAcceptedChannelSize_ = 0L;
                onChanged();
                return this;
            }

            @Override
            public boolean hasExpireTimeSecs() {
                return (this.bitField0_ & 4) == 4;
            }

            @Override
            public long getExpireTimeSecs() {
                return this.expireTimeSecs_;
            }

            public Builder setExpireTimeSecs(long j) {
                this.bitField0_ |= 4;
                this.expireTimeSecs_ = j;
                onChanged();
                return this;
            }

            public Builder clearExpireTimeSecs() {
                this.bitField0_ &= -5;
                this.expireTimeSecs_ = 0L;
                onChanged();
                return this;
            }

            @Override
            public boolean hasMinPayment() {
                return (this.bitField0_ & 8) == 8;
            }

            @Override
            public long getMinPayment() {
                return this.minPayment_;
            }

            public Builder setMinPayment(long j) {
                this.bitField0_ |= 8;
                this.minPayment_ = j;
                onChanged();
                return this;
            }

            public Builder clearMinPayment() {
                this.bitField0_ &= -9;
                this.minPayment_ = 0L;
                onChanged();
                return this;
            }
        }
    }

    public static final class ProvideRefund extends GeneratedMessage implements ProvideRefundOrBuilder {
        public static final int MULTISIG_KEY_FIELD_NUMBER = 1;
        public static Parser<ProvideRefund> PARSER = new AbstractParser<ProvideRefund>() {
            public ProvideRefund parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new ProvideRefund(codedInputStream, extensionRegistryLite);
            }
        };
        public static final int TX_FIELD_NUMBER = 2;
        private static final ProvideRefund defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private ByteString multisigKey_;
        private ByteString tx_;
        private final UnknownFieldSet unknownFields;

        private ProvideRefund(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private ProvideRefund(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static ProvideRefund getDefaultInstance() {
            return defaultInstance;
        }

        public ProvideRefund m1681getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private ProvideRefund(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        try {
                            int readTag = codedInputStream.readTag();
                            if (readTag != 0) {
                                if (readTag == 10) {
                                    this.bitField0_ |= 1;
                                    this.multisigKey_ = codedInputStream.readBytes();
                                } else if (readTag != 18) {
                                    if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                    }
                                } else {
                                    this.bitField0_ |= 2;
                                    this.tx_ = codedInputStream.readBytes();
                                }
                            }
                            z = true;
                        } catch (IOException e) {
                            throw new InvalidProtocolBufferException(e.getMessage()).setUnfinishedMessage(this);
                        }
                    } catch (InvalidProtocolBufferException e2) {
                        throw e2.setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return Protos.internal_static_paymentchannels_ProvideRefund_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return Protos.internal_static_paymentchannels_ProvideRefund_fieldAccessorTable.ensureFieldAccessorsInitialized(ProvideRefund.class, Builder.class);
        }

        static {
            ProvideRefund provideRefund = new ProvideRefund(true);
            defaultInstance = provideRefund;
            provideRefund.initFields();
        }

        public Parser<ProvideRefund> getParserForType() {
            return PARSER;
        }

        @Override
        public boolean hasMultisigKey() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public ByteString getMultisigKey() {
            return this.multisigKey_;
        }

        @Override
        public boolean hasTx() {
            return (this.bitField0_ & 2) == 2;
        }

        @Override
        public ByteString getTx() {
            return this.tx_;
        }

        private void initFields() {
            this.multisigKey_ = ByteString.EMPTY;
            this.tx_ = ByteString.EMPTY;
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            if (!hasMultisigKey()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (!hasTx()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeBytes(1, this.multisigKey_);
            }
            if ((this.bitField0_ & 2) == 2) {
                codedOutputStream.writeBytes(2, this.tx_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeBytesSize = (this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeBytesSize(1, this.multisigKey_) : 0;
            if ((this.bitField0_ & 2) == 2) {
                computeBytesSize += CodedOutputStream.computeBytesSize(2, this.tx_);
            }
            int serializedSize = computeBytesSize + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = serializedSize;
            return serializedSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static ProvideRefund parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (ProvideRefund) PARSER.parseFrom(byteString);
        }

        public static ProvideRefund parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (ProvideRefund) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static ProvideRefund parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (ProvideRefund) PARSER.parseFrom(bArr);
        }

        public static ProvideRefund parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (ProvideRefund) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static ProvideRefund parseFrom(InputStream inputStream) throws IOException {
            return (ProvideRefund) PARSER.parseFrom(inputStream);
        }

        public static ProvideRefund parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ProvideRefund) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static ProvideRefund parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (ProvideRefund) PARSER.parseDelimitedFrom(inputStream);
        }

        public static ProvideRefund parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ProvideRefund) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static ProvideRefund parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (ProvideRefund) PARSER.parseFrom(codedInputStream);
        }

        public static ProvideRefund parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ProvideRefund) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1683newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(ProvideRefund provideRefund) {
            return newBuilder().mergeFrom(provideRefund);
        }

        public Builder m1686toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements ProvideRefundOrBuilder {
            private int bitField0_;
            private ByteString multisigKey_;
            private ByteString tx_;

            public static final Descriptors.Descriptor getDescriptor() {
                return Protos.internal_static_paymentchannels_ProvideRefund_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return Protos.internal_static_paymentchannels_ProvideRefund_fieldAccessorTable.ensureFieldAccessorsInitialized(ProvideRefund.class, Builder.class);
            }

            private Builder() {
                this.multisigKey_ = ByteString.EMPTY;
                this.tx_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.multisigKey_ = ByteString.EMPTY;
                this.tx_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                boolean unused = ProvideRefund.alwaysUseFieldBuilders;
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1695clear() {
                super.clear();
                this.multisigKey_ = ByteString.EMPTY;
                this.bitField0_ &= -2;
                this.tx_ = ByteString.EMPTY;
                this.bitField0_ &= -3;
                return this;
            }

            public Builder m1701clone() {
                return create().mergeFrom(m1691buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return Protos.internal_static_paymentchannels_ProvideRefund_descriptor;
            }

            public ProvideRefund m1703getDefaultInstanceForType() {
                return ProvideRefund.getDefaultInstance();
            }

            public ProvideRefund m1689build() {
                ProvideRefund m1691buildPartial = m1691buildPartial();
                if (m1691buildPartial.isInitialized()) {
                    return m1691buildPartial;
                }
                throw newUninitializedMessageException(m1691buildPartial);
            }

            public ProvideRefund m1691buildPartial() {
                ProvideRefund provideRefund = new ProvideRefund(this);
                int i = this.bitField0_;
                int i2 = (i & 1) != 1 ? 0 : 1;
                provideRefund.multisigKey_ = this.multisigKey_;
                if ((i & 2) == 2) {
                    i2 |= 2;
                }
                provideRefund.tx_ = this.tx_;
                provideRefund.bitField0_ = i2;
                onBuilt();
                return provideRefund;
            }

            public Builder m1707mergeFrom(Message message) {
                if (message instanceof ProvideRefund) {
                    return mergeFrom((ProvideRefund) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(ProvideRefund provideRefund) {
                if (provideRefund == ProvideRefund.getDefaultInstance()) {
                    return this;
                }
                if (provideRefund.hasMultisigKey()) {
                    setMultisigKey(provideRefund.getMultisigKey());
                }
                if (provideRefund.hasTx()) {
                    setTx(provideRefund.getTx());
                }
                mergeUnknownFields(provideRefund.getUnknownFields());
                return this;
            }

            public final boolean isInitialized() {
                return hasMultisigKey() && hasTx();
            }

            public org.bitcoin.paymentchannel.Protos.ProvideRefund.Builder m1708mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.paymentchannel.Protos.ProvideRefund.Builder.m1708mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.paymentchannel.Protos$ProvideRefund$Builder");
            }

            @Override
            public boolean hasMultisigKey() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public ByteString getMultisigKey() {
                return this.multisigKey_;
            }

            public Builder setMultisigKey(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 1;
                this.multisigKey_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearMultisigKey() {
                this.bitField0_ &= -2;
                this.multisigKey_ = ProvideRefund.getDefaultInstance().getMultisigKey();
                onChanged();
                return this;
            }

            @Override
            public boolean hasTx() {
                return (this.bitField0_ & 2) == 2;
            }

            @Override
            public ByteString getTx() {
                return this.tx_;
            }

            public Builder setTx(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 2;
                this.tx_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearTx() {
                this.bitField0_ &= -3;
                this.tx_ = ProvideRefund.getDefaultInstance().getTx();
                onChanged();
                return this;
            }
        }
    }

    public static final class ReturnRefund extends GeneratedMessage implements ReturnRefundOrBuilder {
        public static Parser<ReturnRefund> PARSER = new AbstractParser<ReturnRefund>() {
            public ReturnRefund parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new ReturnRefund(codedInputStream, extensionRegistryLite);
            }
        };
        public static final int SIGNATURE_FIELD_NUMBER = 1;
        private static final ReturnRefund defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private ByteString signature_;
        private final UnknownFieldSet unknownFields;

        private ReturnRefund(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private ReturnRefund(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static ReturnRefund getDefaultInstance() {
            return defaultInstance;
        }

        public ReturnRefund m1711getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private ReturnRefund(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        try {
                            int readTag = codedInputStream.readTag();
                            if (readTag != 0) {
                                if (readTag != 10) {
                                    if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                    }
                                } else {
                                    this.bitField0_ |= 1;
                                    this.signature_ = codedInputStream.readBytes();
                                }
                            }
                            z = true;
                        } catch (InvalidProtocolBufferException e) {
                            throw e.setUnfinishedMessage(this);
                        }
                    } catch (IOException e2) {
                        throw new InvalidProtocolBufferException(e2.getMessage()).setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return Protos.internal_static_paymentchannels_ReturnRefund_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return Protos.internal_static_paymentchannels_ReturnRefund_fieldAccessorTable.ensureFieldAccessorsInitialized(ReturnRefund.class, Builder.class);
        }

        static {
            ReturnRefund returnRefund = new ReturnRefund(true);
            defaultInstance = returnRefund;
            returnRefund.initFields();
        }

        public Parser<ReturnRefund> getParserForType() {
            return PARSER;
        }

        @Override
        public boolean hasSignature() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public ByteString getSignature() {
            return this.signature_;
        }

        private void initFields() {
            this.signature_ = ByteString.EMPTY;
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            if (!hasSignature()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeBytes(1, this.signature_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeBytesSize = ((this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeBytesSize(1, this.signature_) : 0) + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = computeBytesSize;
            return computeBytesSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static ReturnRefund parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (ReturnRefund) PARSER.parseFrom(byteString);
        }

        public static ReturnRefund parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (ReturnRefund) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static ReturnRefund parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (ReturnRefund) PARSER.parseFrom(bArr);
        }

        public static ReturnRefund parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (ReturnRefund) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static ReturnRefund parseFrom(InputStream inputStream) throws IOException {
            return (ReturnRefund) PARSER.parseFrom(inputStream);
        }

        public static ReturnRefund parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ReturnRefund) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static ReturnRefund parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (ReturnRefund) PARSER.parseDelimitedFrom(inputStream);
        }

        public static ReturnRefund parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ReturnRefund) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static ReturnRefund parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (ReturnRefund) PARSER.parseFrom(codedInputStream);
        }

        public static ReturnRefund parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ReturnRefund) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1713newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(ReturnRefund returnRefund) {
            return newBuilder().mergeFrom(returnRefund);
        }

        public Builder m1716toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements ReturnRefundOrBuilder {
            private int bitField0_;
            private ByteString signature_;

            public static final Descriptors.Descriptor getDescriptor() {
                return Protos.internal_static_paymentchannels_ReturnRefund_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return Protos.internal_static_paymentchannels_ReturnRefund_fieldAccessorTable.ensureFieldAccessorsInitialized(ReturnRefund.class, Builder.class);
            }

            private Builder() {
                this.signature_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.signature_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                boolean unused = ReturnRefund.alwaysUseFieldBuilders;
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1725clear() {
                super.clear();
                this.signature_ = ByteString.EMPTY;
                this.bitField0_ &= -2;
                return this;
            }

            public Builder m1731clone() {
                return create().mergeFrom(m1721buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return Protos.internal_static_paymentchannels_ReturnRefund_descriptor;
            }

            public ReturnRefund m1733getDefaultInstanceForType() {
                return ReturnRefund.getDefaultInstance();
            }

            public ReturnRefund m1719build() {
                ReturnRefund m1721buildPartial = m1721buildPartial();
                if (m1721buildPartial.isInitialized()) {
                    return m1721buildPartial;
                }
                throw newUninitializedMessageException(m1721buildPartial);
            }

            public ReturnRefund m1721buildPartial() {
                ReturnRefund returnRefund = new ReturnRefund(this);
                int i = (this.bitField0_ & 1) != 1 ? 0 : 1;
                returnRefund.signature_ = this.signature_;
                returnRefund.bitField0_ = i;
                onBuilt();
                return returnRefund;
            }

            public Builder m1737mergeFrom(Message message) {
                if (message instanceof ReturnRefund) {
                    return mergeFrom((ReturnRefund) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(ReturnRefund returnRefund) {
                if (returnRefund == ReturnRefund.getDefaultInstance()) {
                    return this;
                }
                if (returnRefund.hasSignature()) {
                    setSignature(returnRefund.getSignature());
                }
                mergeUnknownFields(returnRefund.getUnknownFields());
                return this;
            }

            public final boolean isInitialized() {
                return hasSignature();
            }

            public org.bitcoin.paymentchannel.Protos.ReturnRefund.Builder m1738mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.paymentchannel.Protos.ReturnRefund.Builder.m1738mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.paymentchannel.Protos$ReturnRefund$Builder");
            }

            @Override
            public boolean hasSignature() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public ByteString getSignature() {
                return this.signature_;
            }

            public Builder setSignature(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 1;
                this.signature_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearSignature() {
                this.bitField0_ &= -2;
                this.signature_ = ReturnRefund.getDefaultInstance().getSignature();
                onChanged();
                return this;
            }
        }
    }

    public static final class ProvideContract extends GeneratedMessage implements ProvideContractOrBuilder {
        public static final int CLIENT_KEY_FIELD_NUMBER = 3;
        public static final int INITIAL_PAYMENT_FIELD_NUMBER = 2;
        public static Parser<ProvideContract> PARSER = new AbstractParser<ProvideContract>() {
            public ProvideContract parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new ProvideContract(codedInputStream, extensionRegistryLite);
            }
        };
        public static final int TX_FIELD_NUMBER = 1;
        private static final ProvideContract defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private ByteString clientKey_;
        private UpdatePayment initialPayment_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private ByteString tx_;
        private final UnknownFieldSet unknownFields;

        private ProvideContract(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private ProvideContract(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static ProvideContract getDefaultInstance() {
            return defaultInstance;
        }

        public ProvideContract m1651getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private ProvideContract(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        int readTag = codedInputStream.readTag();
                        if (readTag != 0) {
                            if (readTag == 10) {
                                this.bitField0_ |= 1;
                                this.tx_ = codedInputStream.readBytes();
                            } else if (readTag == 18) {
                                UpdatePayment.Builder m1837toBuilder = (this.bitField0_ & 2) == 2 ? this.initialPayment_.m1837toBuilder() : null;
                                UpdatePayment updatePayment = (UpdatePayment) codedInputStream.readMessage(UpdatePayment.PARSER, extensionRegistryLite);
                                this.initialPayment_ = updatePayment;
                                if (m1837toBuilder != null) {
                                    m1837toBuilder.mergeFrom(updatePayment);
                                    this.initialPayment_ = m1837toBuilder.m1842buildPartial();
                                }
                                this.bitField0_ |= 2;
                            } else if (readTag != 26) {
                                if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                }
                            } else {
                                this.bitField0_ |= 4;
                                this.clientKey_ = codedInputStream.readBytes();
                            }
                        }
                        z = true;
                    } catch (IOException e) {
                        throw new InvalidProtocolBufferException(e.getMessage()).setUnfinishedMessage(this);
                    } catch (InvalidProtocolBufferException e2) {
                        throw e2.setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return Protos.internal_static_paymentchannels_ProvideContract_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return Protos.internal_static_paymentchannels_ProvideContract_fieldAccessorTable.ensureFieldAccessorsInitialized(ProvideContract.class, Builder.class);
        }

        static {
            ProvideContract provideContract = new ProvideContract(true);
            defaultInstance = provideContract;
            provideContract.initFields();
        }

        public Parser<ProvideContract> getParserForType() {
            return PARSER;
        }

        @Override
        public boolean hasTx() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public ByteString getTx() {
            return this.tx_;
        }

        @Override
        public boolean hasInitialPayment() {
            return (this.bitField0_ & 2) == 2;
        }

        @Override
        public UpdatePayment getInitialPayment() {
            return this.initialPayment_;
        }

        @Override
        public UpdatePaymentOrBuilder getInitialPaymentOrBuilder() {
            return this.initialPayment_;
        }

        @Override
        public boolean hasClientKey() {
            return (this.bitField0_ & 4) == 4;
        }

        @Override
        public ByteString getClientKey() {
            return this.clientKey_;
        }

        private void initFields() {
            this.tx_ = ByteString.EMPTY;
            this.initialPayment_ = UpdatePayment.getDefaultInstance();
            this.clientKey_ = ByteString.EMPTY;
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            if (!hasTx()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (!hasInitialPayment()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (!getInitialPayment().isInitialized()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeBytes(1, this.tx_);
            }
            if ((this.bitField0_ & 2) == 2) {
                codedOutputStream.writeMessage(2, this.initialPayment_);
            }
            if ((this.bitField0_ & 4) == 4) {
                codedOutputStream.writeBytes(3, this.clientKey_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeBytesSize = (this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeBytesSize(1, this.tx_) : 0;
            if ((this.bitField0_ & 2) == 2) {
                computeBytesSize += CodedOutputStream.computeMessageSize(2, this.initialPayment_);
            }
            if ((this.bitField0_ & 4) == 4) {
                computeBytesSize += CodedOutputStream.computeBytesSize(3, this.clientKey_);
            }
            int serializedSize = computeBytesSize + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = serializedSize;
            return serializedSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static ProvideContract parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (ProvideContract) PARSER.parseFrom(byteString);
        }

        public static ProvideContract parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (ProvideContract) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static ProvideContract parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (ProvideContract) PARSER.parseFrom(bArr);
        }

        public static ProvideContract parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (ProvideContract) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static ProvideContract parseFrom(InputStream inputStream) throws IOException {
            return (ProvideContract) PARSER.parseFrom(inputStream);
        }

        public static ProvideContract parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ProvideContract) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static ProvideContract parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (ProvideContract) PARSER.parseDelimitedFrom(inputStream);
        }

        public static ProvideContract parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ProvideContract) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static ProvideContract parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (ProvideContract) PARSER.parseFrom(codedInputStream);
        }

        public static ProvideContract parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (ProvideContract) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1653newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(ProvideContract provideContract) {
            return newBuilder().mergeFrom(provideContract);
        }

        public Builder m1656toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements ProvideContractOrBuilder {
            private int bitField0_;
            private ByteString clientKey_;
            private SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> initialPaymentBuilder_;
            private UpdatePayment initialPayment_;
            private ByteString tx_;

            public static final Descriptors.Descriptor getDescriptor() {
                return Protos.internal_static_paymentchannels_ProvideContract_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return Protos.internal_static_paymentchannels_ProvideContract_fieldAccessorTable.ensureFieldAccessorsInitialized(ProvideContract.class, Builder.class);
            }

            private Builder() {
                this.tx_ = ByteString.EMPTY;
                this.initialPayment_ = UpdatePayment.getDefaultInstance();
                this.clientKey_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.tx_ = ByteString.EMPTY;
                this.initialPayment_ = UpdatePayment.getDefaultInstance();
                this.clientKey_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                if (ProvideContract.alwaysUseFieldBuilders) {
                    getInitialPaymentFieldBuilder();
                }
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1665clear() {
                super.clear();
                this.tx_ = ByteString.EMPTY;
                this.bitField0_ &= -2;
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.initialPaymentBuilder_;
                if (singleFieldBuilder == null) {
                    this.initialPayment_ = UpdatePayment.getDefaultInstance();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -3;
                this.clientKey_ = ByteString.EMPTY;
                this.bitField0_ &= -5;
                return this;
            }

            public Builder m1671clone() {
                return create().mergeFrom(m1661buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return Protos.internal_static_paymentchannels_ProvideContract_descriptor;
            }

            public ProvideContract m1673getDefaultInstanceForType() {
                return ProvideContract.getDefaultInstance();
            }

            public ProvideContract m1659build() {
                ProvideContract m1661buildPartial = m1661buildPartial();
                if (m1661buildPartial.isInitialized()) {
                    return m1661buildPartial;
                }
                throw newUninitializedMessageException(m1661buildPartial);
            }

            public ProvideContract m1661buildPartial() {
                ProvideContract provideContract = new ProvideContract(this);
                int i = this.bitField0_;
                int i2 = (i & 1) != 1 ? 0 : 1;
                provideContract.tx_ = this.tx_;
                if ((i & 2) == 2) {
                    i2 |= 2;
                }
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.initialPaymentBuilder_;
                if (singleFieldBuilder == null) {
                    provideContract.initialPayment_ = this.initialPayment_;
                } else {
                    provideContract.initialPayment_ = (UpdatePayment) singleFieldBuilder.build();
                }
                if ((i & 4) == 4) {
                    i2 |= 4;
                }
                provideContract.clientKey_ = this.clientKey_;
                provideContract.bitField0_ = i2;
                onBuilt();
                return provideContract;
            }

            public Builder m1677mergeFrom(Message message) {
                if (message instanceof ProvideContract) {
                    return mergeFrom((ProvideContract) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(ProvideContract provideContract) {
                if (provideContract == ProvideContract.getDefaultInstance()) {
                    return this;
                }
                if (provideContract.hasTx()) {
                    setTx(provideContract.getTx());
                }
                if (provideContract.hasInitialPayment()) {
                    mergeInitialPayment(provideContract.getInitialPayment());
                }
                if (provideContract.hasClientKey()) {
                    setClientKey(provideContract.getClientKey());
                }
                mergeUnknownFields(provideContract.getUnknownFields());
                return this;
            }

            public final boolean isInitialized() {
                return hasTx() && hasInitialPayment() && getInitialPayment().isInitialized();
            }

            public org.bitcoin.paymentchannel.Protos.ProvideContract.Builder m1678mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.paymentchannel.Protos.ProvideContract.Builder.m1678mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.paymentchannel.Protos$ProvideContract$Builder");
            }

            @Override
            public boolean hasTx() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public ByteString getTx() {
                return this.tx_;
            }

            public Builder setTx(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 1;
                this.tx_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearTx() {
                this.bitField0_ &= -2;
                this.tx_ = ProvideContract.getDefaultInstance().getTx();
                onChanged();
                return this;
            }

            @Override
            public boolean hasInitialPayment() {
                return (this.bitField0_ & 2) == 2;
            }

            @Override
            public UpdatePayment getInitialPayment() {
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.initialPaymentBuilder_;
                if (singleFieldBuilder == null) {
                    return this.initialPayment_;
                }
                return (UpdatePayment) singleFieldBuilder.getMessage();
            }

            public Builder setInitialPayment(UpdatePayment updatePayment) {
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.initialPaymentBuilder_;
                if (singleFieldBuilder != null) {
                    singleFieldBuilder.setMessage(updatePayment);
                } else {
                    if (updatePayment == null) {
                        throw null;
                    }
                    this.initialPayment_ = updatePayment;
                    onChanged();
                }
                this.bitField0_ |= 2;
                return this;
            }

            public Builder setInitialPayment(UpdatePayment.Builder builder) {
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.initialPaymentBuilder_;
                if (singleFieldBuilder == null) {
                    this.initialPayment_ = builder.m1840build();
                    onChanged();
                } else {
                    singleFieldBuilder.setMessage(builder.m1840build());
                }
                this.bitField0_ |= 2;
                return this;
            }

            public Builder mergeInitialPayment(UpdatePayment updatePayment) {
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.initialPaymentBuilder_;
                if (singleFieldBuilder == null) {
                    if ((this.bitField0_ & 2) == 2 && this.initialPayment_ != UpdatePayment.getDefaultInstance()) {
                        this.initialPayment_ = UpdatePayment.newBuilder(this.initialPayment_).mergeFrom(updatePayment).m1842buildPartial();
                    } else {
                        this.initialPayment_ = updatePayment;
                    }
                    onChanged();
                } else {
                    singleFieldBuilder.mergeFrom(updatePayment);
                }
                this.bitField0_ |= 2;
                return this;
            }

            public Builder clearInitialPayment() {
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.initialPaymentBuilder_;
                if (singleFieldBuilder == null) {
                    this.initialPayment_ = UpdatePayment.getDefaultInstance();
                    onChanged();
                } else {
                    singleFieldBuilder.clear();
                }
                this.bitField0_ &= -3;
                return this;
            }

            public UpdatePayment.Builder getInitialPaymentBuilder() {
                this.bitField0_ |= 2;
                onChanged();
                return (UpdatePayment.Builder) getInitialPaymentFieldBuilder().getBuilder();
            }

            @Override
            public UpdatePaymentOrBuilder getInitialPaymentOrBuilder() {
                SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> singleFieldBuilder = this.initialPaymentBuilder_;
                if (singleFieldBuilder != null) {
                    return (UpdatePaymentOrBuilder) singleFieldBuilder.getMessageOrBuilder();
                }
                return this.initialPayment_;
            }

            private SingleFieldBuilder<UpdatePayment, UpdatePayment.Builder, UpdatePaymentOrBuilder> getInitialPaymentFieldBuilder() {
                if (this.initialPaymentBuilder_ == null) {
                    this.initialPaymentBuilder_ = new SingleFieldBuilder<>(getInitialPayment(), getParentForChildren(), isClean());
                    this.initialPayment_ = null;
                }
                return this.initialPaymentBuilder_;
            }

            @Override
            public boolean hasClientKey() {
                return (this.bitField0_ & 4) == 4;
            }

            @Override
            public ByteString getClientKey() {
                return this.clientKey_;
            }

            public Builder setClientKey(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 4;
                this.clientKey_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearClientKey() {
                this.bitField0_ &= -5;
                this.clientKey_ = ProvideContract.getDefaultInstance().getClientKey();
                onChanged();
                return this;
            }
        }
    }

    public static final class UpdatePayment extends GeneratedMessage implements UpdatePaymentOrBuilder {
        public static final int CLIENT_CHANGE_VALUE_FIELD_NUMBER = 1;
        public static final int INFO_FIELD_NUMBER = 3;
        public static Parser<UpdatePayment> PARSER = new AbstractParser<UpdatePayment>() {
            public UpdatePayment parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new UpdatePayment(codedInputStream, extensionRegistryLite);
            }
        };
        public static final int SIGNATURE_FIELD_NUMBER = 2;
        private static final UpdatePayment defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private long clientChangeValue_;
        private ByteString info_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private ByteString signature_;
        private final UnknownFieldSet unknownFields;

        private UpdatePayment(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private UpdatePayment(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static UpdatePayment getDefaultInstance() {
            return defaultInstance;
        }

        public UpdatePayment m1832getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private UpdatePayment(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        int readTag = codedInputStream.readTag();
                        if (readTag != 0) {
                            if (readTag == 8) {
                                this.bitField0_ |= 1;
                                this.clientChangeValue_ = codedInputStream.readUInt64();
                            } else if (readTag == 18) {
                                this.bitField0_ |= 2;
                                this.signature_ = codedInputStream.readBytes();
                            } else if (readTag != 26) {
                                if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                }
                            } else {
                                this.bitField0_ |= 4;
                                this.info_ = codedInputStream.readBytes();
                            }
                        }
                        z = true;
                    } catch (InvalidProtocolBufferException e) {
                        throw e.setUnfinishedMessage(this);
                    } catch (IOException e2) {
                        throw new InvalidProtocolBufferException(e2.getMessage()).setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return Protos.internal_static_paymentchannels_UpdatePayment_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return Protos.internal_static_paymentchannels_UpdatePayment_fieldAccessorTable.ensureFieldAccessorsInitialized(UpdatePayment.class, Builder.class);
        }

        static {
            UpdatePayment updatePayment = new UpdatePayment(true);
            defaultInstance = updatePayment;
            updatePayment.initFields();
        }

        public Parser<UpdatePayment> getParserForType() {
            return PARSER;
        }

        @Override
        public boolean hasClientChangeValue() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public long getClientChangeValue() {
            return this.clientChangeValue_;
        }

        @Override
        public boolean hasSignature() {
            return (this.bitField0_ & 2) == 2;
        }

        @Override
        public ByteString getSignature() {
            return this.signature_;
        }

        @Override
        public boolean hasInfo() {
            return (this.bitField0_ & 4) == 4;
        }

        @Override
        public ByteString getInfo() {
            return this.info_;
        }

        private void initFields() {
            this.clientChangeValue_ = 0L;
            this.signature_ = ByteString.EMPTY;
            this.info_ = ByteString.EMPTY;
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            if (!hasClientChangeValue()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            if (!hasSignature()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeUInt64(1, this.clientChangeValue_);
            }
            if ((this.bitField0_ & 2) == 2) {
                codedOutputStream.writeBytes(2, this.signature_);
            }
            if ((this.bitField0_ & 4) == 4) {
                codedOutputStream.writeBytes(3, this.info_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeUInt64Size = (this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeUInt64Size(1, this.clientChangeValue_) : 0;
            if ((this.bitField0_ & 2) == 2) {
                computeUInt64Size += CodedOutputStream.computeBytesSize(2, this.signature_);
            }
            if ((this.bitField0_ & 4) == 4) {
                computeUInt64Size += CodedOutputStream.computeBytesSize(3, this.info_);
            }
            int serializedSize = computeUInt64Size + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = serializedSize;
            return serializedSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static UpdatePayment parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (UpdatePayment) PARSER.parseFrom(byteString);
        }

        public static UpdatePayment parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (UpdatePayment) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static UpdatePayment parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (UpdatePayment) PARSER.parseFrom(bArr);
        }

        public static UpdatePayment parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (UpdatePayment) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static UpdatePayment parseFrom(InputStream inputStream) throws IOException {
            return (UpdatePayment) PARSER.parseFrom(inputStream);
        }

        public static UpdatePayment parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (UpdatePayment) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static UpdatePayment parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (UpdatePayment) PARSER.parseDelimitedFrom(inputStream);
        }

        public static UpdatePayment parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (UpdatePayment) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static UpdatePayment parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (UpdatePayment) PARSER.parseFrom(codedInputStream);
        }

        public static UpdatePayment parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (UpdatePayment) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1834newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(UpdatePayment updatePayment) {
            return newBuilder().mergeFrom(updatePayment);
        }

        public Builder m1837toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements UpdatePaymentOrBuilder {
            private int bitField0_;
            private long clientChangeValue_;
            private ByteString info_;
            private ByteString signature_;

            public static final Descriptors.Descriptor getDescriptor() {
                return Protos.internal_static_paymentchannels_UpdatePayment_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return Protos.internal_static_paymentchannels_UpdatePayment_fieldAccessorTable.ensureFieldAccessorsInitialized(UpdatePayment.class, Builder.class);
            }

            private Builder() {
                this.signature_ = ByteString.EMPTY;
                this.info_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.signature_ = ByteString.EMPTY;
                this.info_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                boolean unused = UpdatePayment.alwaysUseFieldBuilders;
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1846clear() {
                super.clear();
                this.clientChangeValue_ = 0L;
                this.bitField0_ &= -2;
                this.signature_ = ByteString.EMPTY;
                this.bitField0_ &= -3;
                this.info_ = ByteString.EMPTY;
                this.bitField0_ &= -5;
                return this;
            }

            public Builder m1852clone() {
                return create().mergeFrom(m1842buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return Protos.internal_static_paymentchannels_UpdatePayment_descriptor;
            }

            public UpdatePayment m1854getDefaultInstanceForType() {
                return UpdatePayment.getDefaultInstance();
            }

            public UpdatePayment m1840build() {
                UpdatePayment m1842buildPartial = m1842buildPartial();
                if (m1842buildPartial.isInitialized()) {
                    return m1842buildPartial;
                }
                throw newUninitializedMessageException(m1842buildPartial);
            }

            public UpdatePayment m1842buildPartial() {
                UpdatePayment updatePayment = new UpdatePayment(this);
                int i = this.bitField0_;
                int i2 = (i & 1) != 1 ? 0 : 1;
                updatePayment.clientChangeValue_ = this.clientChangeValue_;
                if ((i & 2) == 2) {
                    i2 |= 2;
                }
                updatePayment.signature_ = this.signature_;
                if ((i & 4) == 4) {
                    i2 |= 4;
                }
                updatePayment.info_ = this.info_;
                updatePayment.bitField0_ = i2;
                onBuilt();
                return updatePayment;
            }

            public Builder m1858mergeFrom(Message message) {
                if (message instanceof UpdatePayment) {
                    return mergeFrom((UpdatePayment) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(UpdatePayment updatePayment) {
                if (updatePayment == UpdatePayment.getDefaultInstance()) {
                    return this;
                }
                if (updatePayment.hasClientChangeValue()) {
                    setClientChangeValue(updatePayment.getClientChangeValue());
                }
                if (updatePayment.hasSignature()) {
                    setSignature(updatePayment.getSignature());
                }
                if (updatePayment.hasInfo()) {
                    setInfo(updatePayment.getInfo());
                }
                mergeUnknownFields(updatePayment.getUnknownFields());
                return this;
            }

            public final boolean isInitialized() {
                return hasClientChangeValue() && hasSignature();
            }

            public org.bitcoin.paymentchannel.Protos.UpdatePayment.Builder m1859mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.paymentchannel.Protos.UpdatePayment.Builder.m1859mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.paymentchannel.Protos$UpdatePayment$Builder");
            }

            @Override
            public boolean hasClientChangeValue() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public long getClientChangeValue() {
                return this.clientChangeValue_;
            }

            public Builder setClientChangeValue(long j) {
                this.bitField0_ |= 1;
                this.clientChangeValue_ = j;
                onChanged();
                return this;
            }

            public Builder clearClientChangeValue() {
                this.bitField0_ &= -2;
                this.clientChangeValue_ = 0L;
                onChanged();
                return this;
            }

            @Override
            public boolean hasSignature() {
                return (this.bitField0_ & 2) == 2;
            }

            @Override
            public ByteString getSignature() {
                return this.signature_;
            }

            public Builder setSignature(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 2;
                this.signature_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearSignature() {
                this.bitField0_ &= -3;
                this.signature_ = UpdatePayment.getDefaultInstance().getSignature();
                onChanged();
                return this;
            }

            @Override
            public boolean hasInfo() {
                return (this.bitField0_ & 4) == 4;
            }

            @Override
            public ByteString getInfo() {
                return this.info_;
            }

            public Builder setInfo(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 4;
                this.info_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearInfo() {
                this.bitField0_ &= -5;
                this.info_ = UpdatePayment.getDefaultInstance().getInfo();
                onChanged();
                return this;
            }
        }
    }

    public static final class PaymentAck extends GeneratedMessage implements PaymentAckOrBuilder {
        public static final int INFO_FIELD_NUMBER = 1;
        public static Parser<PaymentAck> PARSER = new AbstractParser<PaymentAck>() {
            public PaymentAck parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new PaymentAck(codedInputStream, extensionRegistryLite);
            }
        };
        private static final PaymentAck defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private ByteString info_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private final UnknownFieldSet unknownFields;

        private PaymentAck(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private PaymentAck(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static PaymentAck getDefaultInstance() {
            return defaultInstance;
        }

        public PaymentAck m1621getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private PaymentAck(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        try {
                            int readTag = codedInputStream.readTag();
                            if (readTag != 0) {
                                if (readTag != 10) {
                                    if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                    }
                                } else {
                                    this.bitField0_ |= 1;
                                    this.info_ = codedInputStream.readBytes();
                                }
                            }
                            z = true;
                        } catch (InvalidProtocolBufferException e) {
                            throw e.setUnfinishedMessage(this);
                        }
                    } catch (IOException e2) {
                        throw new InvalidProtocolBufferException(e2.getMessage()).setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return Protos.internal_static_paymentchannels_PaymentAck_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return Protos.internal_static_paymentchannels_PaymentAck_fieldAccessorTable.ensureFieldAccessorsInitialized(PaymentAck.class, Builder.class);
        }

        static {
            PaymentAck paymentAck = new PaymentAck(true);
            defaultInstance = paymentAck;
            paymentAck.initFields();
        }

        public Parser<PaymentAck> getParserForType() {
            return PARSER;
        }

        @Override
        public boolean hasInfo() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public ByteString getInfo() {
            return this.info_;
        }

        private void initFields() {
            this.info_ = ByteString.EMPTY;
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeBytes(1, this.info_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeBytesSize = ((this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeBytesSize(1, this.info_) : 0) + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = computeBytesSize;
            return computeBytesSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static PaymentAck parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (PaymentAck) PARSER.parseFrom(byteString);
        }

        public static PaymentAck parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (PaymentAck) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static PaymentAck parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (PaymentAck) PARSER.parseFrom(bArr);
        }

        public static PaymentAck parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (PaymentAck) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static PaymentAck parseFrom(InputStream inputStream) throws IOException {
            return (PaymentAck) PARSER.parseFrom(inputStream);
        }

        public static PaymentAck parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (PaymentAck) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static PaymentAck parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (PaymentAck) PARSER.parseDelimitedFrom(inputStream);
        }

        public static PaymentAck parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (PaymentAck) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static PaymentAck parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (PaymentAck) PARSER.parseFrom(codedInputStream);
        }

        public static PaymentAck parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (PaymentAck) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1623newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(PaymentAck paymentAck) {
            return newBuilder().mergeFrom(paymentAck);
        }

        public Builder m1626toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements PaymentAckOrBuilder {
            private int bitField0_;
            private ByteString info_;

            public final boolean isInitialized() {
                return true;
            }

            public static final Descriptors.Descriptor getDescriptor() {
                return Protos.internal_static_paymentchannels_PaymentAck_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return Protos.internal_static_paymentchannels_PaymentAck_fieldAccessorTable.ensureFieldAccessorsInitialized(PaymentAck.class, Builder.class);
            }

            private Builder() {
                this.info_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.info_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                boolean unused = PaymentAck.alwaysUseFieldBuilders;
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1635clear() {
                super.clear();
                this.info_ = ByteString.EMPTY;
                this.bitField0_ &= -2;
                return this;
            }

            public Builder m1641clone() {
                return create().mergeFrom(m1631buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return Protos.internal_static_paymentchannels_PaymentAck_descriptor;
            }

            public PaymentAck m1643getDefaultInstanceForType() {
                return PaymentAck.getDefaultInstance();
            }

            public PaymentAck m1629build() {
                PaymentAck m1631buildPartial = m1631buildPartial();
                if (m1631buildPartial.isInitialized()) {
                    return m1631buildPartial;
                }
                throw newUninitializedMessageException(m1631buildPartial);
            }

            public PaymentAck m1631buildPartial() {
                PaymentAck paymentAck = new PaymentAck(this);
                int i = (this.bitField0_ & 1) != 1 ? 0 : 1;
                paymentAck.info_ = this.info_;
                paymentAck.bitField0_ = i;
                onBuilt();
                return paymentAck;
            }

            public Builder m1647mergeFrom(Message message) {
                if (message instanceof PaymentAck) {
                    return mergeFrom((PaymentAck) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(PaymentAck paymentAck) {
                if (paymentAck == PaymentAck.getDefaultInstance()) {
                    return this;
                }
                if (paymentAck.hasInfo()) {
                    setInfo(paymentAck.getInfo());
                }
                mergeUnknownFields(paymentAck.getUnknownFields());
                return this;
            }

            public org.bitcoin.paymentchannel.Protos.PaymentAck.Builder m1648mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.paymentchannel.Protos.PaymentAck.Builder.m1648mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.paymentchannel.Protos$PaymentAck$Builder");
            }

            @Override
            public boolean hasInfo() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public ByteString getInfo() {
                return this.info_;
            }

            public Builder setInfo(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 1;
                this.info_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearInfo() {
                this.bitField0_ &= -2;
                this.info_ = PaymentAck.getDefaultInstance().getInfo();
                onChanged();
                return this;
            }
        }
    }

    public static final class Settlement extends GeneratedMessage implements SettlementOrBuilder {
        public static Parser<Settlement> PARSER = new AbstractParser<Settlement>() {
            public Settlement parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new Settlement(codedInputStream, extensionRegistryLite);
            }
        };
        public static final int TX_FIELD_NUMBER = 3;
        private static final Settlement defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private ByteString tx_;
        private final UnknownFieldSet unknownFields;

        private Settlement(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private Settlement(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static Settlement getDefaultInstance() {
            return defaultInstance;
        }

        public Settlement m1771getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private Settlement(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        try {
                            int readTag = codedInputStream.readTag();
                            if (readTag != 0) {
                                if (readTag != 26) {
                                    if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                    }
                                } else {
                                    this.bitField0_ |= 1;
                                    this.tx_ = codedInputStream.readBytes();
                                }
                            }
                            z = true;
                        } catch (InvalidProtocolBufferException e) {
                            throw e.setUnfinishedMessage(this);
                        }
                    } catch (IOException e2) {
                        throw new InvalidProtocolBufferException(e2.getMessage()).setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return Protos.internal_static_paymentchannels_Settlement_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return Protos.internal_static_paymentchannels_Settlement_fieldAccessorTable.ensureFieldAccessorsInitialized(Settlement.class, Builder.class);
        }

        static {
            Settlement settlement = new Settlement(true);
            defaultInstance = settlement;
            settlement.initFields();
        }

        public Parser<Settlement> getParserForType() {
            return PARSER;
        }

        @Override
        public boolean hasTx() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public ByteString getTx() {
            return this.tx_;
        }

        private void initFields() {
            this.tx_ = ByteString.EMPTY;
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            if (!hasTx()) {
                this.memoizedIsInitialized = (byte) 0;
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeBytes(3, this.tx_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeBytesSize = ((this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeBytesSize(3, this.tx_) : 0) + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = computeBytesSize;
            return computeBytesSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static Settlement parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (Settlement) PARSER.parseFrom(byteString);
        }

        public static Settlement parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (Settlement) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static Settlement parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (Settlement) PARSER.parseFrom(bArr);
        }

        public static Settlement parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (Settlement) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static Settlement parseFrom(InputStream inputStream) throws IOException {
            return (Settlement) PARSER.parseFrom(inputStream);
        }

        public static Settlement parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (Settlement) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static Settlement parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (Settlement) PARSER.parseDelimitedFrom(inputStream);
        }

        public static Settlement parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (Settlement) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static Settlement parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (Settlement) PARSER.parseFrom(codedInputStream);
        }

        public static Settlement parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (Settlement) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1773newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(Settlement settlement) {
            return newBuilder().mergeFrom(settlement);
        }

        public Builder m1776toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements SettlementOrBuilder {
            private int bitField0_;
            private ByteString tx_;

            public static final Descriptors.Descriptor getDescriptor() {
                return Protos.internal_static_paymentchannels_Settlement_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return Protos.internal_static_paymentchannels_Settlement_fieldAccessorTable.ensureFieldAccessorsInitialized(Settlement.class, Builder.class);
            }

            private Builder() {
                this.tx_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.tx_ = ByteString.EMPTY;
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                boolean unused = Settlement.alwaysUseFieldBuilders;
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1785clear() {
                super.clear();
                this.tx_ = ByteString.EMPTY;
                this.bitField0_ &= -2;
                return this;
            }

            public Builder m1791clone() {
                return create().mergeFrom(m1781buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return Protos.internal_static_paymentchannels_Settlement_descriptor;
            }

            public Settlement m1793getDefaultInstanceForType() {
                return Settlement.getDefaultInstance();
            }

            public Settlement m1779build() {
                Settlement m1781buildPartial = m1781buildPartial();
                if (m1781buildPartial.isInitialized()) {
                    return m1781buildPartial;
                }
                throw newUninitializedMessageException(m1781buildPartial);
            }

            public Settlement m1781buildPartial() {
                Settlement settlement = new Settlement(this);
                int i = (this.bitField0_ & 1) != 1 ? 0 : 1;
                settlement.tx_ = this.tx_;
                settlement.bitField0_ = i;
                onBuilt();
                return settlement;
            }

            public Builder m1797mergeFrom(Message message) {
                if (message instanceof Settlement) {
                    return mergeFrom((Settlement) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(Settlement settlement) {
                if (settlement == Settlement.getDefaultInstance()) {
                    return this;
                }
                if (settlement.hasTx()) {
                    setTx(settlement.getTx());
                }
                mergeUnknownFields(settlement.getUnknownFields());
                return this;
            }

            public final boolean isInitialized() {
                return hasTx();
            }

            public org.bitcoin.paymentchannel.Protos.Settlement.Builder m1798mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.paymentchannel.Protos.Settlement.Builder.m1798mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.paymentchannel.Protos$Settlement$Builder");
            }

            @Override
            public boolean hasTx() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public ByteString getTx() {
                return this.tx_;
            }

            public Builder setTx(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 1;
                this.tx_ = byteString;
                onChanged();
                return this;
            }

            public Builder clearTx() {
                this.bitField0_ &= -2;
                this.tx_ = Settlement.getDefaultInstance().getTx();
                onChanged();
                return this;
            }
        }
    }

    public static final class Error extends GeneratedMessage implements ErrorOrBuilder {
        public static final int CODE_FIELD_NUMBER = 1;
        public static final int EXPECTED_VALUE_FIELD_NUMBER = 3;
        public static final int EXPLANATION_FIELD_NUMBER = 2;
        public static Parser<Error> PARSER = new AbstractParser<Error>() {
            public Error parsePartialFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
                return new Error(codedInputStream, extensionRegistryLite);
            }
        };
        private static final Error defaultInstance;
        private static final long serialVersionUID = 0;
        private int bitField0_;
        private ErrorCode code_;
        private long expectedValue_;
        private Object explanation_;
        private byte memoizedIsInitialized;
        private int memoizedSerializedSize;
        private final UnknownFieldSet unknownFields;

        private Error(GeneratedMessage.Builder<?> builder) {
            super(builder);
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = builder.getUnknownFields();
        }

        private Error(boolean z) {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            this.unknownFields = UnknownFieldSet.getDefaultInstance();
        }

        public static Error getDefaultInstance() {
            return defaultInstance;
        }

        public Error m1560getDefaultInstanceForType() {
            return defaultInstance;
        }

        public final UnknownFieldSet getUnknownFields() {
            return this.unknownFields;
        }

        private Error(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            this.memoizedIsInitialized = (byte) -1;
            this.memoizedSerializedSize = -1;
            initFields();
            UnknownFieldSet.Builder newBuilder = UnknownFieldSet.newBuilder();
            boolean z = false;
            while (!z) {
                try {
                    try {
                        int readTag = codedInputStream.readTag();
                        if (readTag != 0) {
                            if (readTag == 8) {
                                int readEnum = codedInputStream.readEnum();
                                ErrorCode valueOf = ErrorCode.valueOf(readEnum);
                                if (valueOf == null) {
                                    newBuilder.mergeVarintField(1, readEnum);
                                } else {
                                    this.bitField0_ |= 1;
                                    this.code_ = valueOf;
                                }
                            } else if (readTag == 18) {
                                ByteString readBytes = codedInputStream.readBytes();
                                this.bitField0_ |= 2;
                                this.explanation_ = readBytes;
                            } else if (readTag != 24) {
                                if (!parseUnknownField(codedInputStream, newBuilder, extensionRegistryLite, readTag)) {
                                }
                            } else {
                                this.bitField0_ |= 4;
                                this.expectedValue_ = codedInputStream.readUInt64();
                            }
                        }
                        z = true;
                    } catch (InvalidProtocolBufferException e) {
                        throw e.setUnfinishedMessage(this);
                    } catch (IOException e2) {
                        throw new InvalidProtocolBufferException(e2.getMessage()).setUnfinishedMessage(this);
                    }
                } finally {
                    this.unknownFields = newBuilder.build();
                    makeExtensionsImmutable();
                }
            }
        }

        public static final Descriptors.Descriptor getDescriptor() {
            return Protos.internal_static_paymentchannels_Error_descriptor;
        }

        protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
            return Protos.internal_static_paymentchannels_Error_fieldAccessorTable.ensureFieldAccessorsInitialized(Error.class, Builder.class);
        }

        static {
            Error error = new Error(true);
            defaultInstance = error;
            error.initFields();
        }

        public Parser<Error> getParserForType() {
            return PARSER;
        }

        public enum ErrorCode implements ProtocolMessageEnum {
            TIMEOUT(0, 1),
            SYNTAX_ERROR(1, 2),
            NO_ACCEPTABLE_VERSION(2, 3),
            BAD_TRANSACTION(3, 4),
            TIME_WINDOW_UNACCEPTABLE(4, 5),
            CHANNEL_VALUE_TOO_LARGE(5, 6),
            MIN_PAYMENT_TOO_LARGE(6, 7),
            OTHER(7, 8);

            public static final int BAD_TRANSACTION_VALUE = 4;
            public static final int CHANNEL_VALUE_TOO_LARGE_VALUE = 6;
            public static final int MIN_PAYMENT_TOO_LARGE_VALUE = 7;
            public static final int NO_ACCEPTABLE_VERSION_VALUE = 3;
            public static final int OTHER_VALUE = 8;
            public static final int SYNTAX_ERROR_VALUE = 2;
            public static final int TIMEOUT_VALUE = 1;
            public static final int TIME_WINDOW_UNACCEPTABLE_VALUE = 5;
            private final int index;
            private final int value;
            private static Internal.EnumLiteMap<ErrorCode> internalValueMap = new Internal.EnumLiteMap<ErrorCode>() {
                public ErrorCode findValueByNumber(int i) {
                    return ErrorCode.valueOf(i);
                }
            };
            private static final ErrorCode[] VALUES = values();

            public final int getNumber() {
                return this.value;
            }

            public static ErrorCode valueOf(int i) {
                switch (i) {
                    case 1:
                        return TIMEOUT;
                    case 2:
                        return SYNTAX_ERROR;
                    case 3:
                        return NO_ACCEPTABLE_VERSION;
                    case 4:
                        return BAD_TRANSACTION;
                    case 5:
                        return TIME_WINDOW_UNACCEPTABLE;
                    case 6:
                        return CHANNEL_VALUE_TOO_LARGE;
                    case 7:
                        return MIN_PAYMENT_TOO_LARGE;
                    case 8:
                        return OTHER;
                    default:
                        return null;
                }
            }

            public static Internal.EnumLiteMap<ErrorCode> internalGetValueMap() {
                return internalValueMap;
            }

            public final Descriptors.EnumValueDescriptor getValueDescriptor() {
                return (Descriptors.EnumValueDescriptor) getDescriptor().getValues().get(this.index);
            }

            public final Descriptors.EnumDescriptor getDescriptorForType() {
                return getDescriptor();
            }

            public static final Descriptors.EnumDescriptor getDescriptor() {
                return (Descriptors.EnumDescriptor) Error.getDescriptor().getEnumTypes().get(0);
            }

            public static ErrorCode valueOf(Descriptors.EnumValueDescriptor enumValueDescriptor) {
                if (enumValueDescriptor.getType() != getDescriptor()) {
                    throw new IllegalArgumentException("EnumValueDescriptor is not for this type.");
                }
                return VALUES[enumValueDescriptor.getIndex()];
            }

            ErrorCode(int i, int i2) {
                this.index = i;
                this.value = i2;
            }
        }

        @Override
        public boolean hasCode() {
            return (this.bitField0_ & 1) == 1;
        }

        @Override
        public ErrorCode getCode() {
            return this.code_;
        }

        @Override
        public boolean hasExplanation() {
            return (this.bitField0_ & 2) == 2;
        }

        @Override
        public String getExplanation() {
            Object obj = this.explanation_;
            if (obj instanceof String) {
                return (String) obj;
            }
            ByteString byteString = (ByteString) obj;
            String stringUtf8 = byteString.toStringUtf8();
            if (byteString.isValidUtf8()) {
                this.explanation_ = stringUtf8;
            }
            return stringUtf8;
        }

        @Override
        public ByteString getExplanationBytes() {
            Object obj = this.explanation_;
            if (obj instanceof String) {
                ByteString copyFromUtf8 = ByteString.copyFromUtf8((String) obj);
                this.explanation_ = copyFromUtf8;
                return copyFromUtf8;
            }
            return (ByteString) obj;
        }

        @Override
        public boolean hasExpectedValue() {
            return (this.bitField0_ & 4) == 4;
        }

        @Override
        public long getExpectedValue() {
            return this.expectedValue_;
        }

        private void initFields() {
            this.code_ = ErrorCode.OTHER;
            this.explanation_ = "";
            this.expectedValue_ = 0L;
        }

        public final boolean isInitialized() {
            byte b = this.memoizedIsInitialized;
            if (b == 1) {
                return true;
            }
            if (b == 0) {
                return false;
            }
            this.memoizedIsInitialized = (byte) 1;
            return true;
        }

        public void writeTo(CodedOutputStream codedOutputStream) throws IOException {
            getSerializedSize();
            if ((this.bitField0_ & 1) == 1) {
                codedOutputStream.writeEnum(1, this.code_.getNumber());
            }
            if ((this.bitField0_ & 2) == 2) {
                codedOutputStream.writeBytes(2, getExplanationBytes());
            }
            if ((this.bitField0_ & 4) == 4) {
                codedOutputStream.writeUInt64(3, this.expectedValue_);
            }
            getUnknownFields().writeTo(codedOutputStream);
        }

        public int getSerializedSize() {
            int i = this.memoizedSerializedSize;
            if (i != -1) {
                return i;
            }
            int computeEnumSize = (this.bitField0_ & 1) == 1 ? 0 + CodedOutputStream.computeEnumSize(1, this.code_.getNumber()) : 0;
            if ((this.bitField0_ & 2) == 2) {
                computeEnumSize += CodedOutputStream.computeBytesSize(2, getExplanationBytes());
            }
            if ((this.bitField0_ & 4) == 4) {
                computeEnumSize += CodedOutputStream.computeUInt64Size(3, this.expectedValue_);
            }
            int serializedSize = computeEnumSize + getUnknownFields().getSerializedSize();
            this.memoizedSerializedSize = serializedSize;
            return serializedSize;
        }

        protected Object writeReplace() throws ObjectStreamException {
            return super.writeReplace();
        }

        public static Error parseFrom(ByteString byteString) throws InvalidProtocolBufferException {
            return (Error) PARSER.parseFrom(byteString);
        }

        public static Error parseFrom(ByteString byteString, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (Error) PARSER.parseFrom(byteString, extensionRegistryLite);
        }

        public static Error parseFrom(byte[] bArr) throws InvalidProtocolBufferException {
            return (Error) PARSER.parseFrom(bArr);
        }

        public static Error parseFrom(byte[] bArr, ExtensionRegistryLite extensionRegistryLite) throws InvalidProtocolBufferException {
            return (Error) PARSER.parseFrom(bArr, extensionRegistryLite);
        }

        public static Error parseFrom(InputStream inputStream) throws IOException {
            return (Error) PARSER.parseFrom(inputStream);
        }

        public static Error parseFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (Error) PARSER.parseFrom(inputStream, extensionRegistryLite);
        }

        public static Error parseDelimitedFrom(InputStream inputStream) throws IOException {
            return (Error) PARSER.parseDelimitedFrom(inputStream);
        }

        public static Error parseDelimitedFrom(InputStream inputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (Error) PARSER.parseDelimitedFrom(inputStream, extensionRegistryLite);
        }

        public static Error parseFrom(CodedInputStream codedInputStream) throws IOException {
            return (Error) PARSER.parseFrom(codedInputStream);
        }

        public static Error parseFrom(CodedInputStream codedInputStream, ExtensionRegistryLite extensionRegistryLite) throws IOException {
            return (Error) PARSER.parseFrom(codedInputStream, extensionRegistryLite);
        }

        public static Builder newBuilder() {
            return Builder.create();
        }

        public Builder m1562newBuilderForType() {
            return newBuilder();
        }

        public static Builder newBuilder(Error error) {
            return newBuilder().mergeFrom(error);
        }

        public Builder m1565toBuilder() {
            return newBuilder(this);
        }

        public Builder newBuilderForType(GeneratedMessage.BuilderParent builderParent) {
            return new Builder(builderParent);
        }

        public static final class Builder extends GeneratedMessage.Builder<Builder> implements ErrorOrBuilder {
            private int bitField0_;
            private ErrorCode code_;
            private long expectedValue_;
            private Object explanation_;

            public final boolean isInitialized() {
                return true;
            }

            public static final Descriptors.Descriptor getDescriptor() {
                return Protos.internal_static_paymentchannels_Error_descriptor;
            }

            protected GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
                return Protos.internal_static_paymentchannels_Error_fieldAccessorTable.ensureFieldAccessorsInitialized(Error.class, Builder.class);
            }

            private Builder() {
                this.code_ = ErrorCode.OTHER;
                this.explanation_ = "";
                maybeForceBuilderInitialization();
            }

            private Builder(GeneratedMessage.BuilderParent builderParent) {
                super(builderParent);
                this.code_ = ErrorCode.OTHER;
                this.explanation_ = "";
                maybeForceBuilderInitialization();
            }

            private void maybeForceBuilderInitialization() {
                boolean unused = Error.alwaysUseFieldBuilders;
            }

            public static Builder create() {
                return new Builder();
            }

            public Builder m1574clear() {
                super.clear();
                this.code_ = ErrorCode.OTHER;
                int i = this.bitField0_ & (-2);
                this.bitField0_ = i;
                this.explanation_ = "";
                int i2 = i & (-3);
                this.bitField0_ = i2;
                this.expectedValue_ = 0L;
                this.bitField0_ = i2 & (-5);
                return this;
            }

            public Builder m1580clone() {
                return create().mergeFrom(m1570buildPartial());
            }

            public Descriptors.Descriptor getDescriptorForType() {
                return Protos.internal_static_paymentchannels_Error_descriptor;
            }

            public Error m1582getDefaultInstanceForType() {
                return Error.getDefaultInstance();
            }

            public Error m1568build() {
                Error m1570buildPartial = m1570buildPartial();
                if (m1570buildPartial.isInitialized()) {
                    return m1570buildPartial;
                }
                throw newUninitializedMessageException(m1570buildPartial);
            }

            public Error m1570buildPartial() {
                Error error = new Error(this);
                int i = this.bitField0_;
                int i2 = (i & 1) != 1 ? 0 : 1;
                error.code_ = this.code_;
                if ((i & 2) == 2) {
                    i2 |= 2;
                }
                error.explanation_ = this.explanation_;
                if ((i & 4) == 4) {
                    i2 |= 4;
                }
                error.expectedValue_ = this.expectedValue_;
                error.bitField0_ = i2;
                onBuilt();
                return error;
            }

            public Builder m1586mergeFrom(Message message) {
                if (message instanceof Error) {
                    return mergeFrom((Error) message);
                }
                super.mergeFrom(message);
                return this;
            }

            public Builder mergeFrom(Error error) {
                if (error == Error.getDefaultInstance()) {
                    return this;
                }
                if (error.hasCode()) {
                    setCode(error.getCode());
                }
                if (error.hasExplanation()) {
                    this.bitField0_ |= 2;
                    this.explanation_ = error.explanation_;
                    onChanged();
                }
                if (error.hasExpectedValue()) {
                    setExpectedValue(error.getExpectedValue());
                }
                mergeUnknownFields(error.getUnknownFields());
                return this;
            }

            public org.bitcoin.paymentchannel.Protos.Error.Builder m1587mergeFrom(com.google.protobuf.CodedInputStream r3, com.google.protobuf.ExtensionRegistryLite r4) throws java.io.IOException {
                throw new UnsupportedOperationException("Method not decompiled: org.bitcoin.paymentchannel.Protos.Error.Builder.m1587mergeFrom(com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite):org.bitcoin.paymentchannel.Protos$Error$Builder");
            }

            @Override
            public boolean hasCode() {
                return (this.bitField0_ & 1) == 1;
            }

            @Override
            public ErrorCode getCode() {
                return this.code_;
            }

            public Builder setCode(ErrorCode errorCode) {
                if (errorCode == null) {
                    throw null;
                }
                this.bitField0_ |= 1;
                this.code_ = errorCode;
                onChanged();
                return this;
            }

            public Builder clearCode() {
                this.bitField0_ &= -2;
                this.code_ = ErrorCode.OTHER;
                onChanged();
                return this;
            }

            @Override
            public boolean hasExplanation() {
                return (this.bitField0_ & 2) == 2;
            }

            @Override
            public String getExplanation() {
                Object obj = this.explanation_;
                if (!(obj instanceof String)) {
                    ByteString byteString = (ByteString) obj;
                    String stringUtf8 = byteString.toStringUtf8();
                    if (byteString.isValidUtf8()) {
                        this.explanation_ = stringUtf8;
                    }
                    return stringUtf8;
                }
                return (String) obj;
            }

            @Override
            public ByteString getExplanationBytes() {
                Object obj = this.explanation_;
                if (obj instanceof String) {
                    ByteString copyFromUtf8 = ByteString.copyFromUtf8((String) obj);
                    this.explanation_ = copyFromUtf8;
                    return copyFromUtf8;
                }
                return (ByteString) obj;
            }

            public Builder setExplanation(String str) {
                if (str == null) {
                    throw null;
                }
                this.bitField0_ |= 2;
                this.explanation_ = str;
                onChanged();
                return this;
            }

            public Builder clearExplanation() {
                this.bitField0_ &= -3;
                this.explanation_ = Error.getDefaultInstance().getExplanation();
                onChanged();
                return this;
            }

            public Builder setExplanationBytes(ByteString byteString) {
                if (byteString == null) {
                    throw null;
                }
                this.bitField0_ |= 2;
                this.explanation_ = byteString;
                onChanged();
                return this;
            }

            @Override
            public boolean hasExpectedValue() {
                return (this.bitField0_ & 4) == 4;
            }

            @Override
            public long getExpectedValue() {
                return this.expectedValue_;
            }

            public Builder setExpectedValue(long j) {
                this.bitField0_ |= 4;
                this.expectedValue_ = j;
                onChanged();
                return this;
            }

            public Builder clearExpectedValue() {
                this.bitField0_ &= -5;
                this.expectedValue_ = 0L;
                onChanged();
                return this;
            }
        }
    }

    public static Descriptors.FileDescriptor getDescriptor() {
        return descriptor;
    }

    static {
        Descriptors.FileDescriptor.internalBuildGeneratedFileFrom(new String[]{"\n\u0014paymentchannel.proto\u0012\u000fpaymentchannels\"°\u0006\n\u0014TwoWayChannelMessage\u0012?\n\u0004type\u0018\u0001 \u0002(\u000e21.paymentchannels.TwoWayChannelMessage.MessageType\u00126\n\u000eclient_version\u0018\u0002 \u0001(\u000b2\u001e.paymentchannels.ClientVersion\u00126\n\u000eserver_version\u0018\u0003 \u0001(\u000b2\u001e.paymentchannels.ServerVersion\u0012+\n\binitiate\u0018\u0004 \u0001(\u000b2\u0019.paymentchannels.Initiate\u00126\n\u000eprovide_refund\u0018\u0005 \u0001(\u000b2\u001e.paymentchannels.ProvideRefund\u00124\n\rreturn_refund\u0018\u0006 \u0001(\u000b2\u001d.paymentchannels.ReturnRefund\u0012:\n\u0010", "provide_contract\u0018\u0007 \u0001(\u000b2 .paymentchannels.ProvideContract\u00126\n\u000eupdate_payment\u0018\b \u0001(\u000b2\u001e.paymentchannels.UpdatePayment\u00120\n\u000bpayment_ack\u0018\u000b \u0001(\u000b2\u001b.paymentchannels.PaymentAck\u0012/\n\nsettlement\u0018\t \u0001(\u000b2\u001b.paymentchannels.Settlement\u0012%\n\u0005error\u0018\n \u0001(\u000b2\u0016.paymentchannels.Error\"Í\u0001\n\u000bMessageType\u0012\u0012\n\u000eCLIENT_VERSION\u0010\u0001\u0012\u0012\n\u000eSERVER_VERSION\u0010\u0002\u0012\f\n\bINITIATE\u0010\u0003\u0012\u0012\n\u000ePROVIDE_REFUND\u0010\u0004\u0012\u0011\n\rRETURN_REFUND\u0010\u0005\u0012\u0014\n\u0010PROVIDE_CONTRACT\u0010\u0006\u0012\u0010\n\fCHANNEL_OPEN\u0010\u0007\u0012", "\u0012\n\u000eUPDATE_PAYMENT\u0010\b\u0012\u000f\n\u000bPAYMENT_ACK\u0010\u000b\u0012\t\n\u0005CLOSE\u0010\t\u0012\t\n\u0005ERROR\u0010\n\"y\n\rClientVersion\u0012\r\n\u0005major\u0018\u0001 \u0002(\u0005\u0012\u0010\n\u0005minor\u0018\u0002 \u0001(\u0005:\u00010\u0012&\n\u001eprevious_channel_contract_hash\u0018\u0003 \u0001(\f\u0012\u001f\n\u0010time_window_secs\u0018\u0004 \u0001(\u0004:\u000586340\"0\n\rServerVersion\u0012\r\n\u0005major\u0018\u0001 \u0002(\u0005\u0012\u0010\n\u0005minor\u0018\u0002 \u0001(\u0005:\u00010\"r\n\bInitiate\u0012\u0014\n\fmultisig_key\u0018\u0001 \u0002(\f\u0012!\n\u0019min_accepted_channel_size\u0018\u0002 \u0002(\u0004\u0012\u0018\n\u0010expire_time_secs\u0018\u0003 \u0002(\u0004\u0012\u0013\n\u000bmin_payment\u0018\u0004 \u0002(\u0004\"1\n\rProvideRefund\u0012\u0014\n\fmultisig_key\u0018\u0001 \u0002(\f\u0012\n\n\u0002tx\u0018\u0002 \u0002(\f\"!", "\n\fReturnRefund\u0012\u0011\n\tsignature\u0018\u0001 \u0002(\f\"j\n\u000fProvideContract\u0012\n\n\u0002tx\u0018\u0001 \u0002(\f\u00127\n\u000finitial_payment\u0018\u0002 \u0002(\u000b2\u001e.paymentchannels.UpdatePayment\u0012\u0012\n\nclient_key\u0018\u0003 \u0001(\f\"M\n\rUpdatePayment\u0012\u001b\n\u0013client_change_value\u0018\u0001 \u0002(\u0004\u0012\u0011\n\tsignature\u0018\u0002 \u0002(\f\u0012\f\n\u0004info\u0018\u0003 \u0001(\f\"\u001a\n\nPaymentAck\u0012\f\n\u0004info\u0018\u0001 \u0001(\f\"\u0018\n\nSettlement\u0012\n\n\u0002tx\u0018\u0003 \u0002(\f\"©\u0002\n\u0005Error\u00125\n\u0004code\u0018\u0001 \u0001(\u000e2 .paymentchannels.Error.ErrorCode:\u0005OTHER\u0012\u0013\n\u000bexplanation\u0018\u0002 \u0001(\t\u0012\u0016\n\u000eexpected_value\u0018\u0003 \u0001(\u0004\"»\u0001\n\tErrorCode\u0012\u000b", "\n\u0007TIMEOUT\u0010\u0001\u0012\u0010\n\fSYNTAX_ERROR\u0010\u0002\u0012\u0019\n\u0015NO_ACCEPTABLE_VERSION\u0010\u0003\u0012\u0013\n\u000fBAD_TRANSACTION\u0010\u0004\u0012\u001c\n\u0018TIME_WINDOW_UNACCEPTABLE\u0010\u0005\u0012\u001b\n\u0017CHANNEL_VALUE_TOO_LARGE\u0010\u0006\u0012\u0019\n\u0015MIN_PAYMENT_TOO_LARGE\u0010\u0007\u0012\t\n\u0005OTHER\u0010\bB$\n\u001aorg.bitcoin.paymentchannelB\u0006Protos"}, new Descriptors.FileDescriptor[0], new Descriptors.FileDescriptor.InternalDescriptorAssigner() {
            public ExtensionRegistry assignDescriptors(Descriptors.FileDescriptor fileDescriptor) {
                Descriptors.FileDescriptor unused = Protos.descriptor = fileDescriptor;
                return null;
            }
        });
        Descriptors.Descriptor descriptor2 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(0);
        internal_static_paymentchannels_TwoWayChannelMessage_descriptor = descriptor2;
        internal_static_paymentchannels_TwoWayChannelMessage_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor2, new String[]{"Type", "ClientVersion", "ServerVersion", "Initiate", "ProvideRefund", "ReturnRefund", "ProvideContract", "UpdatePayment", "PaymentAck", "Settlement", "Error"});
        Descriptors.Descriptor descriptor3 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(1);
        internal_static_paymentchannels_ClientVersion_descriptor = descriptor3;
        internal_static_paymentchannels_ClientVersion_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor3, new String[]{"Major", "Minor", "PreviousChannelContractHash", "TimeWindowSecs"});
        Descriptors.Descriptor descriptor4 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(2);
        internal_static_paymentchannels_ServerVersion_descriptor = descriptor4;
        internal_static_paymentchannels_ServerVersion_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor4, new String[]{"Major", "Minor"});
        Descriptors.Descriptor descriptor5 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(3);
        internal_static_paymentchannels_Initiate_descriptor = descriptor5;
        internal_static_paymentchannels_Initiate_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor5, new String[]{"MultisigKey", "MinAcceptedChannelSize", "ExpireTimeSecs", "MinPayment"});
        Descriptors.Descriptor descriptor6 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(4);
        internal_static_paymentchannels_ProvideRefund_descriptor = descriptor6;
        internal_static_paymentchannels_ProvideRefund_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor6, new String[]{"MultisigKey", "Tx"});
        Descriptors.Descriptor descriptor7 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(5);
        internal_static_paymentchannels_ReturnRefund_descriptor = descriptor7;
        internal_static_paymentchannels_ReturnRefund_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor7, new String[]{"Signature"});
        Descriptors.Descriptor descriptor8 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(6);
        internal_static_paymentchannels_ProvideContract_descriptor = descriptor8;
        internal_static_paymentchannels_ProvideContract_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor8, new String[]{"Tx", "InitialPayment", "ClientKey"});
        Descriptors.Descriptor descriptor9 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(7);
        internal_static_paymentchannels_UpdatePayment_descriptor = descriptor9;
        internal_static_paymentchannels_UpdatePayment_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor9, new String[]{"ClientChangeValue", "Signature", "Info"});
        Descriptors.Descriptor descriptor10 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(8);
        internal_static_paymentchannels_PaymentAck_descriptor = descriptor10;
        internal_static_paymentchannels_PaymentAck_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor10, new String[]{"Info"});
        Descriptors.Descriptor descriptor11 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(9);
        internal_static_paymentchannels_Settlement_descriptor = descriptor11;
        internal_static_paymentchannels_Settlement_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor11, new String[]{"Tx"});
        Descriptors.Descriptor descriptor12 = (Descriptors.Descriptor) getDescriptor().getMessageTypes().get(10);
        internal_static_paymentchannels_Error_descriptor = descriptor12;
        internal_static_paymentchannels_Error_fieldAccessorTable = new GeneratedMessage.FieldAccessorTable(descriptor12, new String[]{"Code", "Explanation", "ExpectedValue"});
    }
}