public static void Encode(IByteWriter stream, InflationResult encodedInflationResult)
{
XdrEncoding.EncodeInt32((int)encodedInflationResult.Discriminant.InnerValue, stream);
switch (encodedInflationResult.Discriminant.InnerValue)
{
case InflationResultCode.InflationResultCodeEnum.INFLATION_SUCCESS:
int payoutssize = encodedInflationResult.Payouts.Length;
XdrEncoding.EncodeInt32(payoutssize, stream);
for (int i = 0; i < payoutssize; i++)
{
InflationPayout.Encode(stream, encodedInflationResult.Payouts[i]);
}
break;
default:
break;
}
}
public static void Encode(IByteWriter stream, SCPQuorumSet encodedSCPQuorumSet)
{
Uint32.Encode(stream, encodedSCPQuorumSet.Threshold);
int validatorssize = encodedSCPQuorumSet.Validators.Length;
XdrEncoding.EncodeInt32(validatorssize, stream);
for (int i = 0; i < validatorssize; i++)
{
PublicKey.Encode(stream, encodedSCPQuorumSet.Validators[i]);
}
int innerSetssize = encodedSCPQuorumSet.InnerSets.Length;
XdrEncoding.EncodeInt32(innerSetssize, stream);
for (int i = 0; i < innerSetssize; i++)
{
SCPQuorumSet.Encode(stream, encodedSCPQuorumSet.InnerSets[i]);
}
}
public static void Encode(IByteWriter stream, LedgerUpgrade encodedLedgerUpgrade)
{
XdrEncoding.EncodeInt32((int)encodedLedgerUpgrade.Discriminant.InnerValue, stream);
switch (encodedLedgerUpgrade.Discriminant.InnerValue)
{
case LedgerUpgradeType.LedgerUpgradeTypeEnum.LEDGER_UPGRADE_VERSION:
Uint32.Encode(stream, encodedLedgerUpgrade.NewLedgerVersion);
break;
case LedgerUpgradeType.LedgerUpgradeTypeEnum.LEDGER_UPGRADE_BASE_FEE:
Uint32.Encode(stream, encodedLedgerUpgrade.NewBaseFee);
break;
case LedgerUpgradeType.LedgerUpgradeTypeEnum.LEDGER_UPGRADE_MAX_TX_SET_SIZE:
Uint32.Encode(stream, encodedLedgerUpgrade.NewMaxTxSetSize);
break;
}
}
public static void Encode(IByteWriter stream, SignerKey encodedSignerKey)
{
XdrEncoding.EncodeInt32((int)encodedSignerKey.Discriminant.InnerValue, stream);
switch (encodedSignerKey.Discriminant.InnerValue)
{
case SignerKeyType.SignerKeyTypeEnum.SIGNER_KEY_TYPE_ED25519:
Uint256.Encode(stream, encodedSignerKey.Ed25519);
break;
case SignerKeyType.SignerKeyTypeEnum.SIGNER_KEY_TYPE_PRE_AUTH_TX:
Uint256.Encode(stream, encodedSignerKey.PreAuthTx);
break;
case SignerKeyType.SignerKeyTypeEnum.SIGNER_KEY_TYPE_HASH_X:
Uint256.Encode(stream, encodedSignerKey.HashX);
break;
}
}
public static void Encode(IByteWriter stream, TransactionResultResult encodedTransactionResultResult)
{
XdrEncoding.EncodeInt32((int)encodedTransactionResultResult.Discriminant.InnerValue, stream);
switch (encodedTransactionResultResult.Discriminant.InnerValue)
{
case TransactionResultCode.TransactionResultCodeEnum.txSUCCESS:
case TransactionResultCode.TransactionResultCodeEnum.txFAILED:
int resultssize = encodedTransactionResultResult.Results.Length;
XdrEncoding.EncodeInt32(resultssize, stream);
for (int i = 0; i < resultssize; i++)
{
OperationResult.Encode(stream, encodedTransactionResultResult.Results[i]);
}
break;
default:
break;
}
}
public static void Encode(IByteWriter stream, Memo encodedMemo) {
XdrEncoding.EncodeInt32((int)encodedMemo.Discriminant.InnerValue, stream);
switch (encodedMemo.Discriminant.InnerValue) {
case MemoType.MemoTypeEnum.MEMO_NONE:
break;
case MemoType.MemoTypeEnum.MEMO_TEXT:
XdrEncoding.WriteString(stream, encodedMemo.Text);
break;
case MemoType.MemoTypeEnum.MEMO_ID:
Uint64.Encode(stream, encodedMemo.Id);
break;
case MemoType.MemoTypeEnum.MEMO_HASH:
Hash.Encode(stream, encodedMemo.Hash);
break;
case MemoType.MemoTypeEnum.MEMO_RETURN:
Hash.Encode(stream, encodedMemo.RetHash);
break;
}
}
public static void Encode(IByteWriter stream, LedgerEntryData encodedLedgerEntryData)
{
XdrEncoding.EncodeInt32((int)encodedLedgerEntryData.Discriminant.InnerValue, stream);
switch (encodedLedgerEntryData.Discriminant.InnerValue)
{
case LedgerEntryType.LedgerEntryTypeEnum.ACCOUNT:
AccountEntry.Encode(stream, encodedLedgerEntryData.Account);
break;
case LedgerEntryType.LedgerEntryTypeEnum.TRUSTLINE:
TrustLineEntry.Encode(stream, encodedLedgerEntryData.TrustLine);
break;
case LedgerEntryType.LedgerEntryTypeEnum.OFFER:
OfferEntry.Encode(stream, encodedLedgerEntryData.Offer);
break;
case LedgerEntryType.LedgerEntryTypeEnum.DATA:
DataEntry.Encode(stream, encodedLedgerEntryData.Data);
break;
}
}
public static void Encode(IByteWriter stream, SCPStatementPledges encodedSCPStatementPledges)
{
XdrEncoding.EncodeInt32((int)encodedSCPStatementPledges.Discriminant.InnerValue, stream);
switch (encodedSCPStatementPledges.Discriminant.InnerValue)
{
case SCPStatementType.SCPStatementTypeEnum.SCP_ST_PREPARE:
SCPStatementPrepare.Encode(stream, encodedSCPStatementPledges.Prepare);
break;
case SCPStatementType.SCPStatementTypeEnum.SCP_ST_CONFIRM:
SCPStatementConfirm.Encode(stream, encodedSCPStatementPledges.Confirm);
break;
case SCPStatementType.SCPStatementTypeEnum.SCP_ST_EXTERNALIZE:
SCPStatementExternalize.Encode(stream, encodedSCPStatementPledges.Externalize);
break;
case SCPStatementType.SCPStatementTypeEnum.SCP_ST_NOMINATE:
SCPNomination.Encode(stream, encodedSCPStatementPledges.Nominate);
break;
}
}
public static void Encode(IByteWriter stream, LedgerEntryChange encodedLedgerEntryChange)
{
XdrEncoding.EncodeInt32((int)encodedLedgerEntryChange.Discriminant.InnerValue, stream);
switch (encodedLedgerEntryChange.Discriminant.InnerValue)
{
case LedgerEntryChangeType.LedgerEntryChangeTypeEnum.LEDGER_ENTRY_CREATED:
LedgerEntry.Encode(stream, encodedLedgerEntryChange.Created);
break;
case LedgerEntryChangeType.LedgerEntryChangeTypeEnum.LEDGER_ENTRY_UPDATED:
LedgerEntry.Encode(stream, encodedLedgerEntryChange.Updated);
break;
case LedgerEntryChangeType.LedgerEntryChangeTypeEnum.LEDGER_ENTRY_REMOVED:
LedgerKey.Encode(stream, encodedLedgerEntryChange.Removed);
break;
case LedgerEntryChangeType.LedgerEntryChangeTypeEnum.LEDGER_ENTRY_STATE:
LedgerEntry.Encode(stream, encodedLedgerEntryChange.State);
break;
}
}
public static void Encode(IByteWriter stream, LedgerKey encodedLedgerKey)
{
XdrEncoding.EncodeInt32((int)encodedLedgerKey.Discriminant.InnerValue, stream);
switch (encodedLedgerKey.Discriminant.InnerValue)
{
case LedgerEntryType.LedgerEntryTypeEnum.ACCOUNT:
LedgerKeyAccount.Encode(stream, encodedLedgerKey.Account);
break;
case LedgerEntryType.LedgerEntryTypeEnum.TRUSTLINE:
LedgerKeyTrustLine.Encode(stream, encodedLedgerKey.TrustLine);
break;
case LedgerEntryType.LedgerEntryTypeEnum.OFFER:
LedgerKeyOffer.Encode(stream, encodedLedgerKey.Offer);
break;
case LedgerEntryType.LedgerEntryTypeEnum.DATA:
LedgerKeyData.Encode(stream, encodedLedgerKey.Data);
break;
}
}
public static void Encode(IByteWriter stream, Transaction encodedTransaction)
{
AccountID.Encode(stream, encodedTransaction.SourceAccount);
Uint32.Encode(stream, encodedTransaction.Fee);
SequenceNumber.Encode(stream, encodedTransaction.SeqNum);
if (encodedTransaction.TimeBounds != null)
{
XdrEncoding.EncodeInt32(1, stream);
TimeBounds.Encode(stream, encodedTransaction.TimeBounds);
}
else
{
XdrEncoding.EncodeInt32(0, stream);
}
Memo.Encode(stream, encodedTransaction.Memo);
int operationssize = encodedTransaction.Operations.Length;
XdrEncoding.EncodeInt32(operationssize, stream);
for (int i = 0; i < operationssize; i++)
{
Operation.Encode(stream, encodedTransaction.Operations[i]);
}
TransactionExt.Encode(stream, encodedTransaction.Ext);
}
public static void Encode(IByteWriter stream, Int32 encodedInt32)
{
XdrEncoding.EncodeInt32(encodedInt32.InnerValue, stream);
}
public static void Encode(IByteWriter stream, ManageDataResultCode value)
{
XdrEncoding.EncodeInt32((int)value.InnerValue, stream);
}
public static void Encode(IByteWriter stream, StellarMessage encodedStellarMessage)
{
XdrEncoding.EncodeInt32((int)encodedStellarMessage.Discriminant.InnerValue, stream);
switch (encodedStellarMessage.Discriminant.InnerValue)
{
case MessageType.MessageTypeEnum.ERROR_MSG:
Error.Encode(stream, encodedStellarMessage.Error);
break;
case MessageType.MessageTypeEnum.HELLO:
Hello.Encode(stream, encodedStellarMessage.Hello);
break;
case MessageType.MessageTypeEnum.AUTH:
Auth.Encode(stream, encodedStellarMessage.Auth);
break;
case MessageType.MessageTypeEnum.DONT_HAVE:
DontHave.Encode(stream, encodedStellarMessage.DontHave);
break;
case MessageType.MessageTypeEnum.GET_PEERS:
break;
case MessageType.MessageTypeEnum.PEERS:
int peerssize = encodedStellarMessage.Peers.Length;
XdrEncoding.EncodeInt32(peerssize, stream);
for (int i = 0; i < peerssize; i++)
{
PeerAddress.Encode(stream, encodedStellarMessage.Peers[i]);
}
break;
case MessageType.MessageTypeEnum.GET_TX_SET:
Uint256.Encode(stream, encodedStellarMessage.TxSetHash);
break;
case MessageType.MessageTypeEnum.TX_SET:
TransactionSet.Encode(stream, encodedStellarMessage.TxSet);
break;
case MessageType.MessageTypeEnum.TRANSACTION:
TransactionEnvelope.Encode(stream, encodedStellarMessage.Transaction);
break;
case MessageType.MessageTypeEnum.GET_SCP_QUORUMSET:
Uint256.Encode(stream, encodedStellarMessage.QSetHash);
break;
case MessageType.MessageTypeEnum.SCP_QUORUMSET:
SCPQuorumSet.Encode(stream, encodedStellarMessage.QSet);
break;
case MessageType.MessageTypeEnum.SCP_MESSAGE:
SCPEnvelope.Encode(stream, encodedStellarMessage.Envelope);
break;
case MessageType.MessageTypeEnum.GET_SCP_STATE:
Uint32.Encode(stream, encodedStellarMessage.GetSCPLedgerSeq);
break;
}
}
public static void Encode(IByteWriter stream, AccountMergeResultCode value)
{
XdrEncoding.EncodeInt32((int)value.InnerValue, stream);
}
public static void Encode(IByteWriter stream, LedgerEntryChangeType value)
{
XdrEncoding.EncodeInt32((int)value.InnerValue, stream);
}
public static void Encode(IByteWriter stream, OfferEntryFlags value)
{
XdrEncoding.EncodeInt32((int)value.InnerValue, stream);
}
public static void Encode(IByteWriter stream, TransactionResultCode value)
{
XdrEncoding.EncodeInt32((int)value.InnerValue, stream);
}
public static void Encode(IByteWriter stream, ThresholdIndexes value)
{
XdrEncoding.EncodeInt32((int)value.InnerValue, stream);
}
public static void Encode(IByteWriter stream, ManageOfferEffect value)
{
XdrEncoding.EncodeInt32((int)value.InnerValue, stream);
}
public static void Encode(IByteWriter stream, ChangeTrustResultCode value)
{
XdrEncoding.EncodeInt32((int)value.InnerValue, stream);
}
public static void Encode(IByteWriter stream, UpgradeType encodedUpgradeType) {
int UpgradeTypeSize = encodedUpgradeType.InnerValue.Length;
XdrEncoding.EncodeInt32(UpgradeTypeSize, stream);
XdrEncoding.WriteFixOpaque(stream, (uint)UpgradeTypeSize, encodedUpgradeType.InnerValue);
}
public static void Encode(IByteWriter stream, PublicKeyType value)
{
XdrEncoding.EncodeInt32((int)value.InnerValue, stream);
}
public static void Encode(IByteWriter stream, SetOptionsOp encodedSetOptionsOp)
{
if (encodedSetOptionsOp.InflationDest != null)
{
XdrEncoding.EncodeInt32(1, stream);
AccountID.Encode(stream, encodedSetOptionsOp.InflationDest);
}
else
{
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.ClearFlags != null)
{
XdrEncoding.EncodeInt32(1, stream);
Uint32.Encode(stream, encodedSetOptionsOp.ClearFlags);
}
else
{
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.SetFlags != null)
{
XdrEncoding.EncodeInt32(1, stream);
Uint32.Encode(stream, encodedSetOptionsOp.SetFlags);
}
else
{
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.MasterWeight != null)
{
XdrEncoding.EncodeInt32(1, stream);
Uint32.Encode(stream, encodedSetOptionsOp.MasterWeight);
}
else
{
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.LowThreshold != null)
{
XdrEncoding.EncodeInt32(1, stream);
Uint32.Encode(stream, encodedSetOptionsOp.LowThreshold);
}
else
{
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.MedThreshold != null)
{
XdrEncoding.EncodeInt32(1, stream);
Uint32.Encode(stream, encodedSetOptionsOp.MedThreshold);
}
else
{
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.HighThreshold != null)
{
XdrEncoding.EncodeInt32(1, stream);
Uint32.Encode(stream, encodedSetOptionsOp.HighThreshold);
}
else
{
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.HomeDomain != null)
{
XdrEncoding.EncodeInt32(1, stream);
String32.Encode(stream, encodedSetOptionsOp.HomeDomain);
}
else
{
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.Signer != null)
{
XdrEncoding.EncodeInt32(1, stream);
Signer.Encode(stream, encodedSetOptionsOp.Signer);
}
else
{
XdrEncoding.EncodeInt32(0, stream);
}
}
public static void Encode(IByteWriter stream, PathPaymentResultCode value)
{
XdrEncoding.EncodeInt32((int)value.InnerValue, stream);
}
public static void Encode(IByteWriter stream, Auth encodedAuth)
{
XdrEncoding.EncodeInt32(encodedAuth.Unused, stream);
}
