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 DontHave Decode(XdrDataInputStream stream) { DontHave decodedDontHave = new DontHave(); decodedDontHave.Type = MessageType.Decode(stream); decodedDontHave.ReqHash = Uint256.Decode(stream); return(decodedDontHave); }
public static MuxedAccountMed25519 Decode(XdrDataInputStream stream) { MuxedAccountMed25519 decodedMuxedAccountMed25519 = new MuxedAccountMed25519(); decodedMuxedAccountMed25519.Id = Uint64.Decode(stream); decodedMuxedAccountMed25519.Ed25519 = Uint256.Decode(stream); return(decodedMuxedAccountMed25519); }
public static Uint256 Decode(XdrDataInputStream stream) { Uint256 decodedUint256 = new Uint256(); int uint256size = 32; decodedUint256.InnerValue = new byte[uint256size]; stream.Read(decodedUint256.InnerValue, 0, uint256size); return(decodedUint256); }
public static void Encode(XdrDataOutputStream stream, PublicKey encodedPublicKey) { stream.WriteInt((int)encodedPublicKey.Discriminant.InnerValue); switch (encodedPublicKey.Discriminant.InnerValue) { case PublicKeyType.PublicKeyTypeEnum.PUBLIC_KEY_TYPE_ED25519: Uint256.Encode(stream, encodedPublicKey.Ed25519); break; } }
public static void Encode(XdrDataOutputStream stream, Hello encodedHello) { Uint32.Encode(stream, encodedHello.LedgerVersion); Uint32.Encode(stream, encodedHello.OverlayVersion); Uint32.Encode(stream, encodedHello.OverlayMinVersion); Hash.Encode(stream, encodedHello.NetworkID); stream.WriteString(encodedHello.VersionStr); stream.WriteInt(encodedHello.ListeningPort); NodeID.Encode(stream, encodedHello.PeerID); AuthCert.Encode(stream, encodedHello.Cert); Uint256.Encode(stream, encodedHello.Nonce); }
/// <summary> /// Creates a Uint256 from a byte hash. /// </summary> /// <param name="hash"></param> /// <returns>A Uint256</returns> private static sdkxdr.Uint256 CreateUint256(byte[] hash) { if (hash.Length != 32) { throw new ArgumentException("hash must be 32 bytes long"); } var value = new sdkxdr.Uint256(); value.InnerValue = hash; return(value); }
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 void Encode(XdrDataOutputStream stream, MuxedAccount encodedMuxedAccount) { stream.WriteInt((int)encodedMuxedAccount.Discriminant.InnerValue); switch (encodedMuxedAccount.Discriminant.InnerValue) { case CryptoKeyType.CryptoKeyTypeEnum.KEY_TYPE_ED25519: Uint256.Encode(stream, encodedMuxedAccount.Ed25519); break; case CryptoKeyType.CryptoKeyTypeEnum.KEY_TYPE_MUXED_ED25519: MuxedAccountMed25519.Encode(stream, encodedMuxedAccount.Med25519); break; } }
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 void Encode(XdrDataOutputStream stream, SignerKey encodedSignerKey) { stream.WriteInt((int)encodedSignerKey.Discriminant.InnerValue); 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 MuxedAccount Decode(XdrDataInputStream stream) { MuxedAccount decodedMuxedAccount = new MuxedAccount(); CryptoKeyType discriminant = CryptoKeyType.Decode(stream); decodedMuxedAccount.Discriminant = discriminant; switch (decodedMuxedAccount.Discriminant.InnerValue) { case CryptoKeyType.CryptoKeyTypeEnum.KEY_TYPE_ED25519: decodedMuxedAccount.Ed25519 = Uint256.Decode(stream); break; case CryptoKeyType.CryptoKeyTypeEnum.KEY_TYPE_MUXED_ED25519: decodedMuxedAccount.Med25519 = MuxedAccountMed25519.Decode(stream); break; } return(decodedMuxedAccount); }
public static SignerKey Decode(XdrDataInputStream stream) { SignerKey decodedSignerKey = new SignerKey(); SignerKeyType discriminant = SignerKeyType.Decode(stream); decodedSignerKey.Discriminant = discriminant; switch (decodedSignerKey.Discriminant.InnerValue) { case SignerKeyType.SignerKeyTypeEnum.SIGNER_KEY_TYPE_ED25519: decodedSignerKey.Ed25519 = Uint256.Decode(stream); break; case SignerKeyType.SignerKeyTypeEnum.SIGNER_KEY_TYPE_PRE_AUTH_TX: decodedSignerKey.PreAuthTx = Uint256.Decode(stream); break; case SignerKeyType.SignerKeyTypeEnum.SIGNER_KEY_TYPE_HASH_X: decodedSignerKey.HashX = Uint256.Decode(stream); break; } return(decodedSignerKey); }
public static void Encode(XdrDataOutputStream stream, MuxedAccountMed25519 encodedMuxedAccountMed25519) { Uint64.Encode(stream, encodedMuxedAccountMed25519.Id); Uint256.Encode(stream, encodedMuxedAccountMed25519.Ed25519); }
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); }
public static void Encode(XdrDataOutputStream stream, DontHave encodedDontHave) { MessageType.Encode(stream, encodedDontHave.Type); Uint256.Encode(stream, encodedDontHave.ReqHash); }
public static void Encode(XdrDataOutputStream stream, StellarMessage encodedStellarMessage) { stream.WriteInt((int)encodedStellarMessage.Discriminant.InnerValue); 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; stream.WriteInt(peerssize); 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(XdrDataOutputStream stream, Uint256 encodedUint256) { int uint256size = encodedUint256.InnerValue.Length; stream.Write(encodedUint256.InnerValue, 0, uint256size); }