public static OperationResultCode Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(OperationResultCodeEnum.opINNER));
case -1: return(Create(OperationResultCodeEnum.opBAD_AUTH));
case -2: return(Create(OperationResultCodeEnum.opNO_ACCOUNT));
case -3: return(Create(OperationResultCodeEnum.opNOT_SUPPORTED));
case -4: return(Create(OperationResultCodeEnum.opTOO_MANY_SUBENTRIES));
case -5: return(Create(OperationResultCodeEnum.opEXCEEDED_WORK_LIMIT));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static InflationResult Decode(XdrDataInputStream stream)
{
InflationResult decodedInflationResult = new InflationResult();
InflationResultCode discriminant = InflationResultCode.Decode(stream);
decodedInflationResult.Discriminant = discriminant;
switch (decodedInflationResult.Discriminant.InnerValue)
{
case InflationResultCode.InflationResultCodeEnum.INFLATION_SUCCESS:
int payoutssize = stream.ReadInt();
decodedInflationResult.Payouts = new InflationPayout[payoutssize];
for (int i = 0; i < payoutssize; i++)
{
decodedInflationResult.Payouts[i] = InflationPayout.Decode(stream);
}
break;
default:
break;
}
return(decodedInflationResult);
}
public static ChangeTrustResultCode Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(ChangeTrustResultCodeEnum.CHANGE_TRUST_SUCCESS));
case -1: return(Create(ChangeTrustResultCodeEnum.CHANGE_TRUST_MALFORMED));
case -2: return(Create(ChangeTrustResultCodeEnum.CHANGE_TRUST_NO_ISSUER));
case -3: return(Create(ChangeTrustResultCodeEnum.CHANGE_TRUST_INVALID_LIMIT));
case -4: return(Create(ChangeTrustResultCodeEnum.CHANGE_TRUST_LOW_RESERVE));
case -5: return(Create(ChangeTrustResultCodeEnum.CHANGE_TRUST_SELF_NOT_ALLOWED));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static AllowTrustResultCode Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(AllowTrustResultCodeEnum.ALLOW_TRUST_SUCCESS));
case -1: return(Create(AllowTrustResultCodeEnum.ALLOW_TRUST_MALFORMED));
case -2: return(Create(AllowTrustResultCodeEnum.ALLOW_TRUST_NO_TRUST_LINE));
case -3: return(Create(AllowTrustResultCodeEnum.ALLOW_TRUST_TRUST_NOT_REQUIRED));
case -4: return(Create(AllowTrustResultCodeEnum.ALLOW_TRUST_CANT_REVOKE));
case -5: return(Create(AllowTrustResultCodeEnum.ALLOW_TRUST_SELF_NOT_ALLOWED));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static ClaimPredicateType Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(ClaimPredicateTypeEnum.CLAIM_PREDICATE_UNCONDITIONAL));
case 1: return(Create(ClaimPredicateTypeEnum.CLAIM_PREDICATE_AND));
case 2: return(Create(ClaimPredicateTypeEnum.CLAIM_PREDICATE_OR));
case 3: return(Create(ClaimPredicateTypeEnum.CLAIM_PREDICATE_NOT));
case 4: return(Create(ClaimPredicateTypeEnum.CLAIM_PREDICATE_BEFORE_ABSOLUTE_TIME));
case 5: return(Create(ClaimPredicateTypeEnum.CLAIM_PREDICATE_BEFORE_RELATIVE_TIME));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static ClaimClaimableBalanceResultCode Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(ClaimClaimableBalanceResultCodeEnum.CLAIM_CLAIMABLE_BALANCE_SUCCESS));
case -1: return(Create(ClaimClaimableBalanceResultCodeEnum.CLAIM_CLAIMABLE_BALANCE_DOES_NOT_EXIST));
case -2: return(Create(ClaimClaimableBalanceResultCodeEnum.CLAIM_CLAIMABLE_BALANCE_CANNOT_CLAIM));
case -3: return(Create(ClaimClaimableBalanceResultCodeEnum.CLAIM_CLAIMABLE_BALANCE_LINE_FULL));
case -4: return(Create(ClaimClaimableBalanceResultCodeEnum.CLAIM_CLAIMABLE_BALANCE_NO_TRUST));
case -5: return(Create(ClaimClaimableBalanceResultCodeEnum.CLAIM_CLAIMABLE_BALANCE_NOT_AUTHORIZED));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static CreateClaimableBalanceResultCode Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(CreateClaimableBalanceResultCodeEnum.CREATE_CLAIMABLE_BALANCE_SUCCESS));
case -1: return(Create(CreateClaimableBalanceResultCodeEnum.CREATE_CLAIMABLE_BALANCE_MALFORMED));
case -2: return(Create(CreateClaimableBalanceResultCodeEnum.CREATE_CLAIMABLE_BALANCE_LOW_RESERVE));
case -3: return(Create(CreateClaimableBalanceResultCodeEnum.CREATE_CLAIMABLE_BALANCE_NO_TRUST));
case -4: return(Create(CreateClaimableBalanceResultCodeEnum.CREATE_CLAIMABLE_BALANCE_NOT_AUTHORIZED));
case -5: return(Create(CreateClaimableBalanceResultCodeEnum.CREATE_CLAIMABLE_BALANCE_UNDERFUNDED));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static EnvelopeType Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(EnvelopeTypeEnum.ENVELOPE_TYPE_TX_V0));
case 1: return(Create(EnvelopeTypeEnum.ENVELOPE_TYPE_SCP));
case 2: return(Create(EnvelopeTypeEnum.ENVELOPE_TYPE_TX));
case 3: return(Create(EnvelopeTypeEnum.ENVELOPE_TYPE_AUTH));
case 4: return(Create(EnvelopeTypeEnum.ENVELOPE_TYPE_SCPVALUE));
case 5: return(Create(EnvelopeTypeEnum.ENVELOPE_TYPE_TX_FEE_BUMP));
default:
throw new Exception("Unknown enum value: " + value);
}
}
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));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static TransactionResultResult Decode(XdrDataInputStream stream)
{
TransactionResultResult decodedTransactionResultResult = new TransactionResultResult();
TransactionResultCode discriminant = TransactionResultCode.Decode(stream);
decodedTransactionResultResult.Discriminant = discriminant;
switch (decodedTransactionResultResult.Discriminant.InnerValue)
{
case TransactionResultCode.TransactionResultCodeEnum.txSUCCESS:
case TransactionResultCode.TransactionResultCodeEnum.txFAILED:
int resultssize = stream.ReadInt();
decodedTransactionResultResult.Results = new OperationResult[resultssize];
for (int i = 0; i < resultssize; i++)
{
decodedTransactionResultResult.Results[i] = OperationResult.Decode(stream);
}
break;
default:
break;
}
return(decodedTransactionResultResult);
}
public static MessageType Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(MessageTypeEnum.ERROR_MSG));
case 2: return(Create(MessageTypeEnum.AUTH));
case 3: return(Create(MessageTypeEnum.DONT_HAVE));
case 4: return(Create(MessageTypeEnum.GET_PEERS));
case 5: return(Create(MessageTypeEnum.PEERS));
case 6: return(Create(MessageTypeEnum.GET_TX_SET));
case 7: return(Create(MessageTypeEnum.TX_SET));
case 8: return(Create(MessageTypeEnum.TRANSACTION));
case 9: return(Create(MessageTypeEnum.GET_SCP_QUORUMSET));
case 10: return(Create(MessageTypeEnum.SCP_QUORUMSET));
case 11: return(Create(MessageTypeEnum.SCP_MESSAGE));
case 12: return(Create(MessageTypeEnum.GET_SCP_STATE));
case 13: return(Create(MessageTypeEnum.HELLO));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static PathPaymentResultCode Decode(XdrDataInputStream stream)
{
var value = stream.ReadInt();
switch (value)
{
case 0: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_SUCCESS));
case -1: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_MALFORMED));
case -2: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_UNDERFUNDED));
case -3: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_SRC_NO_TRUST));
case -4: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_SRC_NOT_AUTHORIZED));
case -5: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_NO_DESTINATION));
case -6: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_NO_TRUST));
case -7: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_NOT_AUTHORIZED));
case -8: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_LINE_FULL));
case -9: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_NO_ISSUER));
case -10: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_TOO_FEW_OFFERS));
case -11: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_OFFER_CROSS_SELF));
case -12: return(Create(PathPaymentResultCodeEnum.PATH_PAYMENT_OVER_SENDMAX));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static ManageBuyOfferResultCode Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_SUCCESS));
case -1: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_MALFORMED));
case -2: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_SELL_NO_TRUST));
case -3: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_BUY_NO_TRUST));
case -4: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_SELL_NOT_AUTHORIZED));
case -5: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_BUY_NOT_AUTHORIZED));
case -6: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_LINE_FULL));
case -7: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_UNDERFUNDED));
case -8: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_CROSS_SELF));
case -9: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_SELL_NO_ISSUER));
case -10: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_BUY_NO_ISSUER));
case -11: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_NOT_FOUND));
case -12: return(Create(ManageBuyOfferResultCodeEnum.MANAGE_BUY_OFFER_LOW_RESERVE));
default:
throw new Exception("Unknown enum value: " + value);
}
}
public static AccountMergeResultCode Decode(XdrDataInputStream stream)
{
int value = stream.ReadInt();
switch (value)
{
case 0: return(Create(AccountMergeResultCodeEnum.ACCOUNT_MERGE_SUCCESS));
case -1: return(Create(AccountMergeResultCodeEnum.ACCOUNT_MERGE_MALFORMED));
case -2: return(Create(AccountMergeResultCodeEnum.ACCOUNT_MERGE_NO_ACCOUNT));
case -3: return(Create(AccountMergeResultCodeEnum.ACCOUNT_MERGE_IMMUTABLE_SET));
case -4: return(Create(AccountMergeResultCodeEnum.ACCOUNT_MERGE_HAS_SUB_ENTRIES));
case -5: return(Create(AccountMergeResultCodeEnum.ACCOUNT_MERGE_SEQNUM_TOO_FAR));
case -6: return(Create(AccountMergeResultCodeEnum.ACCOUNT_MERGE_DEST_FULL));
default:
throw new Exception("Unknown enum value: " + value);
}
}
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 Int32 Decode(XdrDataInputStream stream)
{
Int32 decodedInt32 = new Int32();
decodedInt32.InnerValue = stream.ReadInt();
return decodedInt32;
}
public static StellarMessage Decode(XdrDataInputStream stream)
{
StellarMessage decodedStellarMessage = new StellarMessage();
MessageType discriminant = MessageType.Decode(stream);
decodedStellarMessage.Discriminant = discriminant;
switch (decodedStellarMessage.Discriminant.InnerValue)
{
case MessageType.MessageTypeEnum.ERROR_MSG:
decodedStellarMessage.Error = Error.Decode(stream);
break;
case MessageType.MessageTypeEnum.HELLO:
decodedStellarMessage.Hello = Hello.Decode(stream);
break;
case MessageType.MessageTypeEnum.AUTH:
decodedStellarMessage.Auth = Auth.Decode(stream);
break;
case MessageType.MessageTypeEnum.DONT_HAVE:
decodedStellarMessage.DontHave = DontHave.Decode(stream);
break;
case MessageType.MessageTypeEnum.GET_PEERS:
break;
case MessageType.MessageTypeEnum.PEERS:
int peerssize = stream.ReadInt();
decodedStellarMessage.Peers = new PeerAddress[peerssize];
for (int i = 0; i < peerssize; i++)
{
decodedStellarMessage.Peers[i] = PeerAddress.Decode(stream);
}
break;
case MessageType.MessageTypeEnum.GET_TX_SET:
decodedStellarMessage.TxSetHash = Uint256.Decode(stream);
break;
case MessageType.MessageTypeEnum.TX_SET:
decodedStellarMessage.TxSet = TransactionSet.Decode(stream);
break;
case MessageType.MessageTypeEnum.TRANSACTION:
decodedStellarMessage.Transaction = TransactionEnvelope.Decode(stream);
break;
case MessageType.MessageTypeEnum.GET_SCP_QUORUMSET:
decodedStellarMessage.QSetHash = Uint256.Decode(stream);
break;
case MessageType.MessageTypeEnum.SCP_QUORUMSET:
decodedStellarMessage.QSet = SCPQuorumSet.Decode(stream);
break;
case MessageType.MessageTypeEnum.SCP_MESSAGE:
decodedStellarMessage.Envelope = SCPEnvelope.Decode(stream);
break;
case MessageType.MessageTypeEnum.GET_SCP_STATE:
decodedStellarMessage.GetSCPLedgerSeq = Uint32.Decode(stream);
break;
}
return(decodedStellarMessage);
}
