public static LedgerHeader Decode(XdrDataInputStream stream)
{
LedgerHeader decodedLedgerHeader = new LedgerHeader();
decodedLedgerHeader.LedgerVersion = Uint32.Decode(stream);
decodedLedgerHeader.PreviousLedgerHash = Hash.Decode(stream);
decodedLedgerHeader.ScpValue = StellarValue.Decode(stream);
decodedLedgerHeader.TxSetResultHash = Hash.Decode(stream);
decodedLedgerHeader.BucketListHash = Hash.Decode(stream);
decodedLedgerHeader.LedgerSeq = Uint32.Decode(stream);
decodedLedgerHeader.TotalCoins = Int64.Decode(stream);
decodedLedgerHeader.FeePool = Int64.Decode(stream);
decodedLedgerHeader.InflationSeq = Uint32.Decode(stream);
decodedLedgerHeader.IdPool = Uint64.Decode(stream);
decodedLedgerHeader.BaseFee = Uint32.Decode(stream);
decodedLedgerHeader.BaseReserve = Uint32.Decode(stream);
decodedLedgerHeader.MaxTxSetSize = Uint32.Decode(stream);
int skipListsize = 4;
decodedLedgerHeader.SkipList = new Hash[skipListsize];
for (int i = 0; i < skipListsize; i++)
{
decodedLedgerHeader.SkipList[i] = Hash.Decode(stream);
}
decodedLedgerHeader.Ext = LedgerHeaderExt.Decode(stream);
return(decodedLedgerHeader);
}
public static Transaction Decode(XdrDataInputStream stream)
{
Transaction decodedTransaction = new Transaction();
decodedTransaction.SourceAccount = MuxedAccount.Decode(stream);
decodedTransaction.Fee = Uint32.Decode(stream);
decodedTransaction.SeqNum = SequenceNumber.Decode(stream);
int TimeBoundsPresent = stream.ReadInt();
if (TimeBoundsPresent != 0)
{
decodedTransaction.TimeBounds = TimeBounds.Decode(stream);
}
decodedTransaction.Memo = Memo.Decode(stream);
int operationssize = stream.ReadInt();
decodedTransaction.Operations = new Operation[operationssize];
for (int i = 0; i < operationssize; i++)
{
decodedTransaction.Operations[i] = Operation.Decode(stream);
}
decodedTransaction.Ext = TransactionExt.Decode(stream);
return(decodedTransaction);
}
public static void Encode(XdrDataOutputStream stream, SetTrustLineFlagsOp encodedSetTrustLineFlagsOp)
{
AccountID.Encode(stream, encodedSetTrustLineFlagsOp.Trustor);
Asset.Encode(stream, encodedSetTrustLineFlagsOp.Asset);
Uint32.Encode(stream, encodedSetTrustLineFlagsOp.ClearFlags);
Uint32.Encode(stream, encodedSetTrustLineFlagsOp.SetFlags);
}
public static AccountEntry Decode(XdrDataInputStream stream)
{
AccountEntry decodedAccountEntry = new AccountEntry();
decodedAccountEntry.AccountID = AccountID.Decode(stream);
decodedAccountEntry.Balance = Int64.Decode(stream);
decodedAccountEntry.SeqNum = SequenceNumber.Decode(stream);
decodedAccountEntry.NumSubEntries = Uint32.Decode(stream);
int InflationDestPresent = stream.ReadInt();
if (InflationDestPresent != 0)
{
decodedAccountEntry.InflationDest = AccountID.Decode(stream);
}
decodedAccountEntry.Flags = Uint32.Decode(stream);
decodedAccountEntry.HomeDomain = String32.Decode(stream);
decodedAccountEntry.Thresholds = Thresholds.Decode(stream);
int signerssize = stream.ReadInt();
decodedAccountEntry.Signers = new Signer[signerssize];
for (int i = 0; i < signerssize; i++)
{
decodedAccountEntry.Signers[i] = Signer.Decode(stream);
}
decodedAccountEntry.Ext = AccountEntryExt.Decode(stream);
return(decodedAccountEntry);
}
public static void Encode(XdrDataOutputStream stream, AccountEntry encodedAccountEntry)
{
AccountID.Encode(stream, encodedAccountEntry.AccountID);
Int64.Encode(stream, encodedAccountEntry.Balance);
SequenceNumber.Encode(stream, encodedAccountEntry.SeqNum);
Uint32.Encode(stream, encodedAccountEntry.NumSubEntries);
if (encodedAccountEntry.InflationDest != null)
{
stream.WriteInt(1);
AccountID.Encode(stream, encodedAccountEntry.InflationDest);
}
else
{
stream.WriteInt(0);
}
Uint32.Encode(stream, encodedAccountEntry.Flags);
String32.Encode(stream, encodedAccountEntry.HomeDomain);
Thresholds.Encode(stream, encodedAccountEntry.Thresholds);
int signerssize = encodedAccountEntry.Signers.Length;
stream.WriteInt(signerssize);
for (int i = 0; i < signerssize; i++)
{
Signer.Encode(stream, encodedAccountEntry.Signers[i]);
}
AccountEntryExt.Encode(stream, encodedAccountEntry.Ext);
}
public static void Encode(XdrDataOutputStream stream, TopologyResponseBody encodedTopologyResponseBody)
{
PeerStatList.Encode(stream, encodedTopologyResponseBody.InboundPeers);
PeerStatList.Encode(stream, encodedTopologyResponseBody.OutboundPeers);
Uint32.Encode(stream, encodedTopologyResponseBody.TotalInboundPeerCount);
Uint32.Encode(stream, encodedTopologyResponseBody.TotalOutboundPeerCount);
}
public static Uint32 Decode(XdrDataInputStream stream)
{
Uint32 decodedUint32 = new Uint32();
decodedUint32.InnerValue = stream.ReadInt();
return(decodedUint32);
}
public static LedgerUpgrade Decode(XdrDataInputStream stream)
{
LedgerUpgrade decodedLedgerUpgrade = new LedgerUpgrade();
LedgerUpgradeType discriminant = LedgerUpgradeType.Decode(stream);
decodedLedgerUpgrade.Discriminant = discriminant;
switch (decodedLedgerUpgrade.Discriminant.InnerValue)
{
case LedgerUpgradeType.LedgerUpgradeTypeEnum.LEDGER_UPGRADE_VERSION:
decodedLedgerUpgrade.NewLedgerVersion = Uint32.Decode(stream);
break;
case LedgerUpgradeType.LedgerUpgradeTypeEnum.LEDGER_UPGRADE_BASE_FEE:
decodedLedgerUpgrade.NewBaseFee = Uint32.Decode(stream);
break;
case LedgerUpgradeType.LedgerUpgradeTypeEnum.LEDGER_UPGRADE_MAX_TX_SET_SIZE:
decodedLedgerUpgrade.NewMaxTxSetSize = Uint32.Decode(stream);
break;
case LedgerUpgradeType.LedgerUpgradeTypeEnum.LEDGER_UPGRADE_BASE_RESERVE:
decodedLedgerUpgrade.NewBaseReserve = Uint32.Decode(stream);
break;
}
return(decodedLedgerUpgrade);
}
public static void Encode(XdrDataOutputStream stream,
SCPStatementExternalize encodedSCPStatementExternalize)
{
SCPBallot.Encode(stream, encodedSCPStatementExternalize.Commit);
Uint32.Encode(stream, encodedSCPStatementExternalize.NH);
Hash.Encode(stream, encodedSCPStatementExternalize.CommitQuorumSetHash);
}
public static void Encode(XdrDataOutputStream stream, SCPStatementPrepare encodedSCPStatementPrepare)
{
Hash.Encode(stream, encodedSCPStatementPrepare.QuorumSetHash);
SCPBallot.Encode(stream, encodedSCPStatementPrepare.Ballot);
if (encodedSCPStatementPrepare.Prepared != null)
{
stream.WriteInt(1);
SCPBallot.Encode(stream, encodedSCPStatementPrepare.Prepared);
}
else
{
stream.WriteInt(0);
}
if (encodedSCPStatementPrepare.PreparedPrime != null)
{
stream.WriteInt(1);
SCPBallot.Encode(stream, encodedSCPStatementPrepare.PreparedPrime);
}
else
{
stream.WriteInt(0);
}
Uint32.Encode(stream, encodedSCPStatementPrepare.NC);
Uint32.Encode(stream, encodedSCPStatementPrepare.NH);
}
public static void Encode(XdrDataOutputStream stream,
TransactionHistoryResultEntry encodedTransactionHistoryResultEntry)
{
Uint32.Encode(stream, encodedTransactionHistoryResultEntry.LedgerSeq);
TransactionResultSet.Encode(stream, encodedTransactionHistoryResultEntry.TxResultSet);
TransactionHistoryResultEntryExt.Encode(stream, encodedTransactionHistoryResultEntry.Ext);
}
public static TransactionV0 Decode(XdrDataInputStream stream)
{
TransactionV0 decodedTransactionV0 = new TransactionV0();
decodedTransactionV0.SourceAccountEd25519 = Uint256.Decode(stream);
decodedTransactionV0.Fee = Uint32.Decode(stream);
decodedTransactionV0.SeqNum = SequenceNumber.Decode(stream);
int TimeBoundsPresent = stream.ReadInt();
if (TimeBoundsPresent != 0)
{
decodedTransactionV0.TimeBounds = TimeBounds.Decode(stream);
}
decodedTransactionV0.Memo = Memo.Decode(stream);
int operationssize = stream.ReadInt();
decodedTransactionV0.Operations = new Operation[operationssize];
for (int i = 0; i < operationssize; i++)
{
decodedTransactionV0.Operations[i] = Operation.Decode(stream);
}
decodedTransactionV0.Ext = TransactionV0Ext.Decode(stream);
return(decodedTransactionV0);
}
public static void Encode(XdrDataOutputStream stream, TransactionV0 encodedTransactionV0)
{
Uint256.Encode(stream, encodedTransactionV0.SourceAccountEd25519);
Uint32.Encode(stream, encodedTransactionV0.Fee);
SequenceNumber.Encode(stream, encodedTransactionV0.SeqNum);
if (encodedTransactionV0.TimeBounds != null)
{
stream.WriteInt(1);
TimeBounds.Encode(stream, encodedTransactionV0.TimeBounds);
}
else
{
stream.WriteInt(0);
}
Memo.Encode(stream, encodedTransactionV0.Memo);
int operationssize = encodedTransactionV0.Operations.Length;
stream.WriteInt(operationssize);
for (int i = 0; i < operationssize; i++)
{
Operation.Encode(stream, encodedTransactionV0.Operations[i]);
}
TransactionV0Ext.Encode(stream, encodedTransactionV0.Ext);
}
public static SetOptionsOp Decode(XdrDataInputStream stream)
{
SetOptionsOp decodedSetOptionsOp = new SetOptionsOp();
int InflationDestPresent = stream.ReadInt();
if (InflationDestPresent != 0)
{
decodedSetOptionsOp.InflationDest = AccountID.Decode(stream);
}
int ClearFlagsPresent = stream.ReadInt();
if (ClearFlagsPresent != 0)
{
decodedSetOptionsOp.ClearFlags = Uint32.Decode(stream);
}
int SetFlagsPresent = stream.ReadInt();
if (SetFlagsPresent != 0)
{
decodedSetOptionsOp.SetFlags = Uint32.Decode(stream);
}
int MasterWeightPresent = stream.ReadInt();
if (MasterWeightPresent != 0)
{
decodedSetOptionsOp.MasterWeight = Uint32.Decode(stream);
}
int LowThresholdPresent = stream.ReadInt();
if (LowThresholdPresent != 0)
{
decodedSetOptionsOp.LowThreshold = Uint32.Decode(stream);
}
int MedThresholdPresent = stream.ReadInt();
if (MedThresholdPresent != 0)
{
decodedSetOptionsOp.MedThreshold = Uint32.Decode(stream);
}
int HighThresholdPresent = stream.ReadInt();
if (HighThresholdPresent != 0)
{
decodedSetOptionsOp.HighThreshold = Uint32.Decode(stream);
}
int HomeDomainPresent = stream.ReadInt();
if (HomeDomainPresent != 0)
{
decodedSetOptionsOp.HomeDomain = String32.Decode(stream);
}
int SignerPresent = stream.ReadInt();
if (SignerPresent != 0)
{
decodedSetOptionsOp.Signer = Signer.Decode(stream);
}
return(decodedSetOptionsOp);
}
public static ClaimableBalanceEntryExtensionV1 Decode(XdrDataInputStream stream)
{
ClaimableBalanceEntryExtensionV1 decodedClaimableBalanceEntryExtensionV1 = new ClaimableBalanceEntryExtensionV1();
decodedClaimableBalanceEntryExtensionV1.Ext = ClaimableBalanceEntryExtensionV1Ext.Decode(stream);
decodedClaimableBalanceEntryExtensionV1.Flags = Uint32.Decode(stream);
return(decodedClaimableBalanceEntryExtensionV1);
}
public static Signer Decode(XdrDataInputStream stream)
{
Signer decodedSigner = new Signer();
decodedSigner.Key = SignerKey.Decode(stream);
decodedSigner.Weight = Uint32.Decode(stream);
return(decodedSigner);
}
public static BucketMetadata Decode(XdrDataInputStream stream)
{
BucketMetadata decodedBucketMetadata = new BucketMetadata();
decodedBucketMetadata.LedgerVersion = Uint32.Decode(stream);
decodedBucketMetadata.Ext = BucketMetadataExt.Decode(stream);
return(decodedBucketMetadata);
}
public static void Encode(XdrDataOutputStream stream, SurveyResponseMessage encodedSurveyResponseMessage)
{
NodeID.Encode(stream, encodedSurveyResponseMessage.SurveyorPeerID);
NodeID.Encode(stream, encodedSurveyResponseMessage.SurveyedPeerID);
Uint32.Encode(stream, encodedSurveyResponseMessage.LedgerNum);
SurveyMessageCommandType.Encode(stream, encodedSurveyResponseMessage.CommandType);
EncryptedBody.Encode(stream, encodedSurveyResponseMessage.EncryptedBody);
}
public static SCPBallot Decode(XdrDataInputStream stream)
{
SCPBallot decodedSCPBallot = new SCPBallot();
decodedSCPBallot.Counter = Uint32.Decode(stream);
decodedSCPBallot.Value = Value.Decode(stream);
return(decodedSCPBallot);
}
public static void Encode(XdrDataOutputStream stream, SurveyRequestMessage encodedSurveyRequestMessage)
{
NodeID.Encode(stream, encodedSurveyRequestMessage.SurveyorPeerID);
NodeID.Encode(stream, encodedSurveyRequestMessage.SurveyedPeerID);
Uint32.Encode(stream, encodedSurveyRequestMessage.LedgerNum);
Curve25519Public.Encode(stream, encodedSurveyRequestMessage.EncryptionKey);
SurveyMessageCommandType.Encode(stream, encodedSurveyRequestMessage.CommandType);
}
public static void Encode(XdrDataOutputStream stream, SCPStatementConfirm encodedSCPStatementConfirm)
{
SCPBallot.Encode(stream, encodedSCPStatementConfirm.Ballot);
Uint32.Encode(stream, encodedSCPStatementConfirm.NPrepared);
Uint32.Encode(stream, encodedSCPStatementConfirm.NCommit);
Uint32.Encode(stream, encodedSCPStatementConfirm.NH);
Hash.Encode(stream, encodedSCPStatementConfirm.QuorumSetHash);
}
public static void Encode(XdrDataOutputStream stream, TrustLineEntry encodedTrustLineEntry)
{
AccountID.Encode(stream, encodedTrustLineEntry.AccountID);
Asset.Encode(stream, encodedTrustLineEntry.Asset);
Int64.Encode(stream, encodedTrustLineEntry.Balance);
Int64.Encode(stream, encodedTrustLineEntry.Limit);
Uint32.Encode(stream, encodedTrustLineEntry.Flags);
TrustLineEntryExt.Encode(stream, encodedTrustLineEntry.Ext);
}
public static SCPStatementExternalize Decode(XdrDataInputStream stream)
{
SCPStatementExternalize decodedSCPStatementExternalize = new SCPStatementExternalize();
decodedSCPStatementExternalize.Commit = SCPBallot.Decode(stream);
decodedSCPStatementExternalize.NH = Uint32.Decode(stream);
decodedSCPStatementExternalize.CommitQuorumSetHash = Hash.Decode(stream);
return(decodedSCPStatementExternalize);
}
public static OperationIDId Decode(XdrDataInputStream stream)
{
OperationIDId decodedOperationIDId = new OperationIDId();
decodedOperationIDId.SourceAccount = MuxedAccount.Decode(stream);
decodedOperationIDId.SeqNum = SequenceNumber.Decode(stream);
decodedOperationIDId.OpNum = Uint32.Decode(stream);
return(decodedOperationIDId);
}
public static LedgerEntry Decode(XdrDataInputStream stream)
{
LedgerEntry decodedLedgerEntry = new LedgerEntry();
decodedLedgerEntry.LastModifiedLedgerSeq = Uint32.Decode(stream);
decodedLedgerEntry.Data = LedgerEntryData.Decode(stream);
decodedLedgerEntry.Ext = LedgerEntryExt.Decode(stream);
return(decodedLedgerEntry);
}
public static TransactionHistoryResultEntry Decode(XdrDataInputStream stream)
{
TransactionHistoryResultEntry decodedTransactionHistoryResultEntry = new TransactionHistoryResultEntry();
decodedTransactionHistoryResultEntry.LedgerSeq = Uint32.Decode(stream);
decodedTransactionHistoryResultEntry.TxResultSet = TransactionResultSet.Decode(stream);
decodedTransactionHistoryResultEntry.Ext = TransactionHistoryResultEntryExt.Decode(stream);
return(decodedTransactionHistoryResultEntry);
}
public static AllowTrustOp Decode(XdrDataInputStream stream)
{
AllowTrustOp decodedAllowTrustOp = new AllowTrustOp();
decodedAllowTrustOp.Trustor = AccountID.Decode(stream);
decodedAllowTrustOp.Asset = AssetCode.Decode(stream);
decodedAllowTrustOp.Authorize = Uint32.Decode(stream);
return(decodedAllowTrustOp);
}
public static PeerAddress Decode(XdrDataInputStream stream)
{
PeerAddress decodedPeerAddress = new PeerAddress();
decodedPeerAddress.Ip = PeerAddressIp.Decode(stream);
decodedPeerAddress.Port = Uint32.Decode(stream);
decodedPeerAddress.NumFailures = Uint32.Decode(stream);
return(decodedPeerAddress);
}
public static SetTrustLineFlagsOp Decode(XdrDataInputStream stream)
{
SetTrustLineFlagsOp decodedSetTrustLineFlagsOp = new SetTrustLineFlagsOp();
decodedSetTrustLineFlagsOp.Trustor = AccountID.Decode(stream);
decodedSetTrustLineFlagsOp.Asset = Asset.Decode(stream);
decodedSetTrustLineFlagsOp.ClearFlags = Uint32.Decode(stream);
decodedSetTrustLineFlagsOp.SetFlags = Uint32.Decode(stream);
return(decodedSetTrustLineFlagsOp);
}
public static TopologyResponseBody Decode(XdrDataInputStream stream)
{
TopologyResponseBody decodedTopologyResponseBody = new TopologyResponseBody();
decodedTopologyResponseBody.InboundPeers = PeerStatList.Decode(stream);
decodedTopologyResponseBody.OutboundPeers = PeerStatList.Decode(stream);
decodedTopologyResponseBody.TotalInboundPeerCount = Uint32.Decode(stream);
decodedTopologyResponseBody.TotalOutboundPeerCount = Uint32.Decode(stream);
return(decodedTopologyResponseBody);
}
