public static TransactionMetaV2 Decode(XdrDataInputStream stream)
{
TransactionMetaV2 decodedTransactionMetaV2 = new TransactionMetaV2();
decodedTransactionMetaV2.TxChangesBefore = LedgerEntryChanges.Decode(stream);
int operationssize = stream.ReadInt();
decodedTransactionMetaV2.Operations = new OperationMeta[operationssize];
for (int i = 0; i < operationssize; i++)
{
decodedTransactionMetaV2.Operations[i] = OperationMeta.Decode(stream);
}
decodedTransactionMetaV2.TxChangesAfter = LedgerEntryChanges.Decode(stream);
return(decodedTransactionMetaV2);
}
public static TransactionHistoryResultEntryExt Decode(XdrDataInputStream stream)
{
TransactionHistoryResultEntryExt decodedTransactionHistoryResultEntryExt =
new TransactionHistoryResultEntryExt();
int discriminant = stream.ReadInt();
decodedTransactionHistoryResultEntryExt.Discriminant = discriminant;
switch (decodedTransactionHistoryResultEntryExt.Discriminant)
{
case 0:
break;
}
return(decodedTransactionHistoryResultEntryExt);
}
public static AuthenticatedMessage Decode(XdrDataInputStream stream)
{
AuthenticatedMessage decodedAuthenticatedMessage = new AuthenticatedMessage();
Uint32 discriminant = Uint32.Decode(stream);
decodedAuthenticatedMessage.Discriminant = discriminant;
switch (decodedAuthenticatedMessage.Discriminant.InnerValue)
{
case 0:
decodedAuthenticatedMessage.V0 = AuthenticatedMessageV0.Decode(stream);
break;
}
return(decodedAuthenticatedMessage);
}
public static SCPHistoryEntry Decode(XdrDataInputStream stream)
{
SCPHistoryEntry decodedSCPHistoryEntry = new SCPHistoryEntry();
int discriminant = stream.ReadInt();
decodedSCPHistoryEntry.Discriminant = discriminant;
switch (decodedSCPHistoryEntry.Discriminant)
{
case 0:
decodedSCPHistoryEntry.V0 = SCPHistoryEntryV0.Decode(stream);
break;
}
return(decodedSCPHistoryEntry);
}
public static Hello Decode(XdrDataInputStream stream)
{
Hello decodedHello = new Hello();
decodedHello.LedgerVersion = Uint32.Decode(stream);
decodedHello.OverlayVersion = Uint32.Decode(stream);
decodedHello.OverlayMinVersion = Uint32.Decode(stream);
decodedHello.NetworkID = Hash.Decode(stream);
decodedHello.VersionStr = stream.ReadString();
decodedHello.ListeningPort = stream.ReadInt();
decodedHello.PeerID = NodeID.Decode(stream);
decodedHello.Cert = AuthCert.Decode(stream);
decodedHello.Nonce = Uint256.Decode(stream);
return(decodedHello);
}
public static LedgerSCPMessages Decode(XdrDataInputStream stream)
{
LedgerSCPMessages decodedLedgerSCPMessages = new LedgerSCPMessages();
decodedLedgerSCPMessages.LedgerSeq = Uint32.Decode(stream);
int messagessize = stream.ReadInt();
decodedLedgerSCPMessages.Messages = new SCPEnvelope[messagessize];
for (int i = 0; i < messagessize; i++)
{
decodedLedgerSCPMessages.Messages[i] = SCPEnvelope.Decode(stream);
}
return(decodedLedgerSCPMessages);
}
public static CreateClaimableBalanceOp Decode(XdrDataInputStream stream)
{
CreateClaimableBalanceOp decodedCreateClaimableBalanceOp = new CreateClaimableBalanceOp();
decodedCreateClaimableBalanceOp.Asset = Asset.Decode(stream);
decodedCreateClaimableBalanceOp.Amount = Int64.Decode(stream);
int claimantssize = stream.ReadInt();
decodedCreateClaimableBalanceOp.Claimants = new Claimant[claimantssize];
for (int i = 0; i < claimantssize; i++)
{
decodedCreateClaimableBalanceOp.Claimants[i] = Claimant.Decode(stream);
}
return(decodedCreateClaimableBalanceOp);
}
public static TransactionSet Decode(XdrDataInputStream stream)
{
TransactionSet decodedTransactionSet = new TransactionSet();
decodedTransactionSet.PreviousLedgerHash = Hash.Decode(stream);
int txssize = stream.ReadInt();
decodedTransactionSet.Txs = new TransactionEnvelope[txssize];
for (int i = 0; i < txssize; i++)
{
decodedTransactionSet.Txs[i] = TransactionEnvelope.Decode(stream);
}
return(decodedTransactionSet);
}
public static PathPaymentStrictReceiveResultSuccess Decode(XdrDataInputStream stream)
{
PathPaymentStrictReceiveResultSuccess decodedPathPaymentStrictReceiveResultSuccess =
new PathPaymentStrictReceiveResultSuccess();
int offerssize = stream.ReadInt();
decodedPathPaymentStrictReceiveResultSuccess.Offers = new ClaimOfferAtom[offerssize];
for (int i = 0; i < offerssize; i++)
{
decodedPathPaymentStrictReceiveResultSuccess.Offers[i] = ClaimOfferAtom.Decode(stream);
}
decodedPathPaymentStrictReceiveResultSuccess.Last = SimplePaymentResult.Decode(stream);
return(decodedPathPaymentStrictReceiveResultSuccess);
}
public static TransactionV1Envelope Decode(XdrDataInputStream stream)
{
TransactionV1Envelope decodedTransactionV1Envelope = new TransactionV1Envelope();
decodedTransactionV1Envelope.Tx = Transaction.Decode(stream);
int signaturessize = stream.ReadInt();
decodedTransactionV1Envelope.Signatures = new DecoratedSignature[signaturessize];
for (int i = 0; i < signaturessize; i++)
{
decodedTransactionV1Envelope.Signatures[i] = DecoratedSignature.Decode(stream);
}
return(decodedTransactionV1Envelope);
}
public static TransactionMetaV1 Decode(XdrDataInputStream stream)
{
TransactionMetaV1 decodedTransactionMetaV1 = new TransactionMetaV1();
decodedTransactionMetaV1.TxChanges = LedgerEntryChanges.Decode(stream);
int operationssize = stream.ReadInt();
decodedTransactionMetaV1.Operations = new OperationMeta[operationssize];
for (int i = 0; i < operationssize; i++)
{
decodedTransactionMetaV1.Operations[i] = OperationMeta.Decode(stream);
}
return(decodedTransactionMetaV1);
}
public static PublicKey Decode(XdrDataInputStream stream)
{
PublicKey decodedPublicKey = new PublicKey();
PublicKeyType discriminant = PublicKeyType.Decode(stream);
decodedPublicKey.Discriminant = discriminant;
switch (decodedPublicKey.Discriminant.InnerValue)
{
case PublicKeyType.PublicKeyTypeEnum.PUBLIC_KEY_TYPE_ED25519:
decodedPublicKey.Ed25519 = Uint256.Decode(stream);
break;
}
return(decodedPublicKey);
}
public static FeeBumpTransactionInnerTx Decode(XdrDataInputStream stream)
{
FeeBumpTransactionInnerTx decodedFeeBumpTransactionInnerTx = new FeeBumpTransactionInnerTx();
EnvelopeType discriminant = EnvelopeType.Decode(stream);
decodedFeeBumpTransactionInnerTx.Discriminant = discriminant;
switch (decodedFeeBumpTransactionInnerTx.Discriminant.InnerValue)
{
case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX:
decodedFeeBumpTransactionInnerTx.V1 = TransactionV1Envelope.Decode(stream);
break;
}
return(decodedFeeBumpTransactionInnerTx);
}
public static OperationType Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(OperationTypeEnum.CREATE_ACCOUNT));
case 1: return(Create(OperationTypeEnum.PAYMENT));
case 2: return(Create(OperationTypeEnum.PATH_PAYMENT_STRICT_RECEIVE));
case 3: return(Create(OperationTypeEnum.MANAGE_SELL_OFFER));
case 4: return(Create(OperationTypeEnum.CREATE_PASSIVE_SELL_OFFER));
case 5: return(Create(OperationTypeEnum.SET_OPTIONS));
case 6: return(Create(OperationTypeEnum.CHANGE_TRUST));
case 7: return(Create(OperationTypeEnum.ALLOW_TRUST));
case 8: return(Create(OperationTypeEnum.ACCOUNT_MERGE));
case 9: return(Create(OperationTypeEnum.INFLATION));
case 10: return(Create(OperationTypeEnum.MANAGE_DATA));
case 11: return(Create(OperationTypeEnum.BUMP_SEQUENCE));
case 12: return(Create(OperationTypeEnum.MANAGE_BUY_OFFER));
case 13: return(Create(OperationTypeEnum.PATH_PAYMENT_STRICT_SEND));
case 14: return(Create(OperationTypeEnum.CREATE_CLAIMABLE_BALANCE));
case 15: return(Create(OperationTypeEnum.CLAIM_CLAIMABLE_BALANCE));
case 16: return(Create(OperationTypeEnum.BEGIN_SPONSORING_FUTURE_RESERVES));
case 17: return(Create(OperationTypeEnum.END_SPONSORING_FUTURE_RESERVES));
case 18: return(Create(OperationTypeEnum.REVOKE_SPONSORSHIP));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static CryptoKeyType Decode(XdrDataInputStream stream)
{
var value = stream.ReadInt();
switch (value)
{
case 0: return(Create(CryptoKeyTypeEnum.KEY_TYPE_ED25519));
case 1: return(Create(CryptoKeyTypeEnum.KEY_TYPE_PRE_AUTH_TX));
case 2: return(Create(CryptoKeyTypeEnum.KEY_TYPE_HASH_X));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static EndSponsoringFutureReservesResult Decode(XdrDataInputStream stream)
{
EndSponsoringFutureReservesResult decodedEndSponsoringFutureReservesResult = new EndSponsoringFutureReservesResult();
EndSponsoringFutureReservesResultCode discriminant = EndSponsoringFutureReservesResultCode.Decode(stream);
decodedEndSponsoringFutureReservesResult.Discriminant = discriminant;
switch (decodedEndSponsoringFutureReservesResult.Discriminant.InnerValue)
{
case EndSponsoringFutureReservesResultCode.EndSponsoringFutureReservesResultCodeEnum.END_SPONSORING_FUTURE_RESERVES_SUCCESS:
break;
default:
break;
}
return(decodedEndSponsoringFutureReservesResult);
}
public static AccountFlags Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 1: return(Create(AccountFlagsEnum.AUTH_REQUIRED_FLAG));
case 2: return(Create(AccountFlagsEnum.AUTH_REVOCABLE_FLAG));
case 4: return(Create(AccountFlagsEnum.AUTH_IMMUTABLE_FLAG));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static LedgerUpgradeType Decode(XdrDataInputStream stream)
{
var value = stream.ReadInt();
switch (value)
{
case 1: return(Create(LedgerUpgradeTypeEnum.LEDGER_UPGRADE_VERSION));
case 2: return(Create(LedgerUpgradeTypeEnum.LEDGER_UPGRADE_BASE_FEE));
case 3: return(Create(LedgerUpgradeTypeEnum.LEDGER_UPGRADE_MAX_TX_SET_SIZE));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static ChangeTrustResult Decode(XdrDataInputStream stream)
{
ChangeTrustResult decodedChangeTrustResult = new ChangeTrustResult();
ChangeTrustResultCode discriminant = ChangeTrustResultCode.Decode(stream);
decodedChangeTrustResult.Discriminant = discriminant;
switch (decodedChangeTrustResult.Discriminant.InnerValue)
{
case ChangeTrustResultCode.ChangeTrustResultCodeEnum.CHANGE_TRUST_SUCCESS:
break;
default:
break;
}
return(decodedChangeTrustResult);
}
public static ClaimClaimableBalanceResult Decode(XdrDataInputStream stream)
{
ClaimClaimableBalanceResult decodedClaimClaimableBalanceResult = new ClaimClaimableBalanceResult();
ClaimClaimableBalanceResultCode discriminant = ClaimClaimableBalanceResultCode.Decode(stream);
decodedClaimClaimableBalanceResult.Discriminant = discriminant;
switch (decodedClaimClaimableBalanceResult.Discriminant.InnerValue)
{
case ClaimClaimableBalanceResultCode.ClaimClaimableBalanceResultCodeEnum.CLAIM_CLAIMABLE_BALANCE_SUCCESS:
break;
default:
break;
}
return(decodedClaimClaimableBalanceResult);
}
public static RevokeSponsorshipResult Decode(XdrDataInputStream stream)
{
RevokeSponsorshipResult decodedRevokeSponsorshipResult = new RevokeSponsorshipResult();
RevokeSponsorshipResultCode discriminant = RevokeSponsorshipResultCode.Decode(stream);
decodedRevokeSponsorshipResult.Discriminant = discriminant;
switch (decodedRevokeSponsorshipResult.Discriminant.InnerValue)
{
case RevokeSponsorshipResultCode.RevokeSponsorshipResultCodeEnum.REVOKE_SPONSORSHIP_SUCCESS:
break;
default:
break;
}
return(decodedRevokeSponsorshipResult);
}
public static AssetType Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(AssetTypeEnum.ASSET_TYPE_NATIVE));
case 1: return(Create(AssetTypeEnum.ASSET_TYPE_CREDIT_ALPHANUM4));
case 2: return(Create(AssetTypeEnum.ASSET_TYPE_CREDIT_ALPHANUM12));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static ManageOfferEffect Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(ManageOfferEffectEnum.MANAGE_OFFER_CREATED));
case 1: return(Create(ManageOfferEffectEnum.MANAGE_OFFER_UPDATED));
case 2: return(Create(ManageOfferEffectEnum.MANAGE_OFFER_DELETED));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static CreateAccountResult Decode(XdrDataInputStream stream)
{
CreateAccountResult decodedCreateAccountResult = new CreateAccountResult();
CreateAccountResultCode discriminant = CreateAccountResultCode.Decode(stream);
decodedCreateAccountResult.Discriminant = discriminant;
switch (decodedCreateAccountResult.Discriminant.InnerValue)
{
case CreateAccountResultCode.CreateAccountResultCodeEnum.CREATE_ACCOUNT_SUCCESS:
break;
default:
break;
}
return(decodedCreateAccountResult);
}
public static BeginSponsoringFutureReservesResult Decode(XdrDataInputStream stream)
{
BeginSponsoringFutureReservesResult decodedBeginSponsoringFutureReservesResult = new BeginSponsoringFutureReservesResult();
BeginSponsoringFutureReservesResultCode discriminant = BeginSponsoringFutureReservesResultCode.Decode(stream);
decodedBeginSponsoringFutureReservesResult.Discriminant = discriminant;
switch (decodedBeginSponsoringFutureReservesResult.Discriminant.InnerValue)
{
case BeginSponsoringFutureReservesResultCode.BeginSponsoringFutureReservesResultCodeEnum.BEGIN_SPONSORING_FUTURE_RESERVES_SUCCESS:
break;
default:
break;
}
return(decodedBeginSponsoringFutureReservesResult);
}
public static AccountEntryExtensionV2 Decode(XdrDataInputStream stream)
{
AccountEntryExtensionV2 decodedAccountEntryExtensionV2 = new AccountEntryExtensionV2();
decodedAccountEntryExtensionV2.NumSponsored = Uint32.Decode(stream);
decodedAccountEntryExtensionV2.NumSponsoring = Uint32.Decode(stream);
int signerSponsoringIDssize = stream.ReadInt();
decodedAccountEntryExtensionV2.SignerSponsoringIDs = new SponsorshipDescriptor[signerSponsoringIDssize];
for (int i = 0; i < signerSponsoringIDssize; i++)
{
decodedAccountEntryExtensionV2.SignerSponsoringIDs[i] = SponsorshipDescriptor.Decode(stream);
}
decodedAccountEntryExtensionV2.Ext = AccountEntryExtensionV2Ext.Decode(stream);
return(decodedAccountEntryExtensionV2);
}
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;
}
return(decodedTransactionSignaturePayloadTaggedTransaction);
}
public static ManageDataResult Decode(XdrDataInputStream stream)
{
ManageDataResult decodedManageDataResult = new ManageDataResult();
ManageDataResultCode discriminant = ManageDataResultCode.Decode(stream);
decodedManageDataResult.Discriminant = discriminant;
switch (decodedManageDataResult.Discriminant.InnerValue)
{
case ManageDataResultCode.ManageDataResultCodeEnum.MANAGE_DATA_SUCCESS:
break;
default:
break;
}
return(decodedManageDataResult);
}
public static BumpSequenceResult Decode(XdrDataInputStream stream)
{
BumpSequenceResult decodedBumpSequenceResult = new BumpSequenceResult();
BumpSequenceResultCode discriminant = BumpSequenceResultCode.Decode(stream);
decodedBumpSequenceResult.Discriminant = discriminant;
switch (decodedBumpSequenceResult.Discriminant.InnerValue)
{
case BumpSequenceResultCode.BumpSequenceResultCodeEnum.BUMP_SEQUENCE_SUCCESS:
break;
default:
break;
}
return(decodedBumpSequenceResult);
}
public static TrustLineFlags Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 1: return(Create(TrustLineFlagsEnum.AUTHORIZED_FLAG));
case 2: return(Create(TrustLineFlagsEnum.AUTHORIZED_TO_MAINTAIN_LIABILITIES_FLAG));
case 4: return(Create(TrustLineFlagsEnum.TRUSTLINE_CLAWBACK_ENABLED_FLAG));
default:
throw new Exception("Unknown enum value: " + value);
}
}
