public static void Encode(XdrDataOutputStream stream, FeeBumpTransaction encodedFeeBumpTransaction)
 {
     MuxedAccount.Encode(stream, encodedFeeBumpTransaction.FeeSource);
     Int64.Encode(stream, encodedFeeBumpTransaction.Fee);
     FeeBumpTransactionInnerTx.Encode(stream, encodedFeeBumpTransaction.InnerTx);
     FeeBumpTransactionExt.Encode(stream, encodedFeeBumpTransaction.Ext);
 }
        public xdr.FeeBumpTransaction ToXdr()
        {
            var fee = new Int64 {
                InnerValue = Fee
            };
            var feeSource = FeeSource.MuxedAccount;

            var inner = new xdr.FeeBumpTransaction.FeeBumpTransactionInnerTx
            {
                Discriminant = new EnvelopeType {
                    InnerValue = EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX
                },
                V1 = new TransactionV1Envelope
                {
                    Tx         = InnerTransaction.ToXdrV1(),
                    Signatures = InnerTransaction.Signatures.ToArray()
                }
            };

            var ext = new xdr.FeeBumpTransaction.FeeBumpTransactionExt {
                Discriminant = 0
            };

            var transaction = new xdr.FeeBumpTransaction
            {
                Fee       = fee,
                FeeSource = feeSource,
                InnerTx   = inner,
                Ext       = ext,
            };

            return(transaction);
        }
        public static FeeBumpTransaction Decode(XdrDataInputStream stream)
        {
            FeeBumpTransaction decodedFeeBumpTransaction = new FeeBumpTransaction();

            decodedFeeBumpTransaction.FeeSource = MuxedAccount.Decode(stream);
            decodedFeeBumpTransaction.Fee       = Int64.Decode(stream);
            decodedFeeBumpTransaction.InnerTx   = FeeBumpTransactionInnerTx.Decode(stream);
            decodedFeeBumpTransaction.Ext       = FeeBumpTransactionExt.Decode(stream);
            return(decodedFeeBumpTransaction);
        }
        public static void Encode(XdrDataOutputStream stream, FeeBumpTransactionEnvelope encodedFeeBumpTransactionEnvelope)
        {
            FeeBumpTransaction.Encode(stream, encodedFeeBumpTransactionEnvelope.Tx);
            int signaturessize = encodedFeeBumpTransactionEnvelope.Signatures.Length;

            stream.WriteInt(signaturessize);
            for (int i = 0; i < signaturessize; i++)
            {
                DecoratedSignature.Encode(stream, encodedFeeBumpTransactionEnvelope.Signatures[i]);
            }
        }
            public static void Encode(XdrDataOutputStream stream, TransactionSignaturePayloadTaggedTransaction encodedTransactionSignaturePayloadTaggedTransaction)
            {
                stream.WriteInt((int)encodedTransactionSignaturePayloadTaggedTransaction.Discriminant.InnerValue);
                switch (encodedTransactionSignaturePayloadTaggedTransaction.Discriminant.InnerValue)
                {
                case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX:
                    Transaction.Encode(stream, encodedTransactionSignaturePayloadTaggedTransaction.Tx);
                    break;

                case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX_FEE_BUMP:
                    FeeBumpTransaction.Encode(stream, encodedTransactionSignaturePayloadTaggedTransaction.FeeBump);
                    break;
                }
            }
        public static FeeBumpTransactionEnvelope Decode(XdrDataInputStream stream)
        {
            FeeBumpTransactionEnvelope decodedFeeBumpTransactionEnvelope = new FeeBumpTransactionEnvelope();

            decodedFeeBumpTransactionEnvelope.Tx = FeeBumpTransaction.Decode(stream);
            int signaturessize = stream.ReadInt();

            decodedFeeBumpTransactionEnvelope.Signatures = new DecoratedSignature[signaturessize];
            for (int i = 0; i < signaturessize; i++)
            {
                decodedFeeBumpTransactionEnvelope.Signatures[i] = DecoratedSignature.Decode(stream);
            }
            return(decodedFeeBumpTransactionEnvelope);
        }
            public static TransactionSignaturePayloadTaggedTransaction Decode(XdrDataInputStream stream)
            {
                TransactionSignaturePayloadTaggedTransaction decodedTransactionSignaturePayloadTaggedTransaction = new TransactionSignaturePayloadTaggedTransaction();
                EnvelopeType discriminant = EnvelopeType.Decode(stream);

                decodedTransactionSignaturePayloadTaggedTransaction.Discriminant = discriminant;
                switch (decodedTransactionSignaturePayloadTaggedTransaction.Discriminant.InnerValue)
                {
                case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX:
                    decodedTransactionSignaturePayloadTaggedTransaction.Tx = Transaction.Decode(stream);
                    break;

                case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX_FEE_BUMP:
                    decodedTransactionSignaturePayloadTaggedTransaction.FeeBump = FeeBumpTransaction.Decode(stream);
                    break;
                }
                return(decodedTransactionSignaturePayloadTaggedTransaction);
            }